Loading libraries
rm(list = ls())
library(MASS)
library(tidyverse)
library(haven)
library(readxl)
library(xml2)
library(rvest)
library(janitor)
library(DataExplorer)
library(countrycode)
library(explore)
library(lme4)
library(lmerTest)
library(broom.mixed)
library(ggplot2)
library(dplyr)
library(scales)
library(tidyr)
library(kableExtra)
library(gmodels)
library(flexplot)
library(corrplot)
library(DescTools)
library(caret)
library(ROSE)
library(randomForest)
library(pROC)
library(mice)
library(glmnet)
library(fastDummies)Loading data
Survey data
data_raw <- read_dta("data/ZA7575.dta")Country-level data sets
This is to join various country-level dataset together:
GDP per capita
This is GDP per capita, PPP (constant 2021 international $). Retrieved from the World Bank (https://data.worldbank.org/indicator/NY.GDP.PCAP.PP.KD) for the year 2019.
# A tibble: 6 × 69
`Country Name` `Country Code` `Indicator Name` `Indicator Code`
<chr> <chr> <chr> <chr>
1 Aruba ABW GDP per capita,… NY.GDP.PCAP.PP.…
2 Africa Eastern and… AFE GDP per capita,… NY.GDP.PCAP.PP.…
3 Afghanistan AFG GDP per capita,… NY.GDP.PCAP.PP.…
4 Africa Western and… AFW GDP per capita,… NY.GDP.PCAP.PP.…
5 Angola AGO GDP per capita,… NY.GDP.PCAP.PP.…
6 Albania ALB GDP per capita,… NY.GDP.PCAP.PP.…
# ℹ 65 more variables: `1960` <lgl>, `1961` <lgl>, `1962` <lgl>,
# `1963` <lgl>, `1964` <lgl>, `1965` <lgl>, `1966` <lgl>,
# `1967` <lgl>, `1968` <lgl>, `1969` <lgl>, `1970` <lgl>,
# `1971` <lgl>, `1972` <lgl>, `1973` <lgl>, `1974` <lgl>,
# `1975` <lgl>, `1976` <lgl>, `1977` <lgl>, `1978` <lgl>,
# `1979` <lgl>, `1980` <lgl>, `1981` <lgl>, `1982` <lgl>,
# `1983` <lgl>, `1984` <lgl>, `1985` <lgl>, `1986` <lgl>, …gdp_data <- gdp_data |>
select(`Country Name`, `Country Code`, `2019`)
gdp_data <- gdp_data |>
rename(country_name = `Country Name`,
country_code = `Country Code`,
gdp_pc_ppp = `2019`)
gdp_data <- gdp_data |>
inner_join(select(codelist, iso3c), by = c("country_code" = "iso3c"))
str(gdp_data)tibble [28 × 3] (S3: tbl_df/tbl/data.frame)
$ country_name: chr [1:28] "Austria" "Belgium" "Bulgaria" "Cyprus" ...
$ country_code: chr [1:28] "AUT" "BEL" "BGR" "CYP" ...
$ gdp_pc_ppp : num [1:28] 64630 60452 27673 46157 47720 ...We now have 28 observations including the UK.
Rural population - to be deleted??????
Retrieved from the World Bank (https://data.worldbank.org/indicator/SP.RUR.TOTL.ZS).
Data on the % of population living in rural areas over total population.
# A tibble: 6 × 64
`Country Name` `Country Code` `Indicator Name` `Indicator Code`
<chr> <chr> <chr> <chr>
1 Aruba ABW Rural populatio… SP.RUR.TOTL.ZS
2 Africa Eastern and… AFE Rural populatio… SP.RUR.TOTL.ZS
3 Afghanistan AFG Rural populatio… SP.RUR.TOTL.ZS
4 Africa Western and… AFW Rural populatio… SP.RUR.TOTL.ZS
5 Angola AGO Rural populatio… SP.RUR.TOTL.ZS
6 Albania ALB Rural populatio… SP.RUR.TOTL.ZS
# ℹ 60 more variables: `1960` <dbl>, `1961` <dbl>, `1962` <dbl>,
# `1963` <dbl>, `1964` <dbl>, `1965` <dbl>, `1966` <dbl>,
# `1967` <dbl>, `1968` <dbl>, `1969` <dbl>, `1970` <dbl>,
# `1971` <dbl>, `1972` <dbl>, `1973` <dbl>, `1974` <dbl>,
# `1975` <dbl>, `1976` <dbl>, `1977` <dbl>, `1978` <dbl>,
# `1979` <dbl>, `1980` <dbl>, `1981` <dbl>, `1982` <dbl>,
# `1983` <dbl>, `1984` <dbl>, `1985` <dbl>, `1986` <dbl>, …# selecting only the relevant year
rural_data <- rural_data |>
select(`Country Name`, `Country Code`, `2019`) |>
clean_names() |>
rename("rural_pop_percentage" = "x2019")
rural_data <- rural_data |>
inner_join(select(codelist, iso3c), by = c("country_code" = "iso3c"))
str(rural_data)tibble [28 × 3] (S3: tbl_df/tbl/data.frame)
$ country_name : chr [1:28] "Austria" "Belgium" "Bulgaria" "Cyprus" ...
$ country_code : chr [1:28] "AUT" "BEL" "BGR" "CYP" ...
$ rural_pop_percentage: num [1:28] 41.48 1.96 24.65 33.2 26.08 ...LGBT rights
Found this LGBT rights index on Our World in Data (https://ourworldindata.org/grapher/lgbt-rights-index) which captures whether LGBT+ people enjoy the same rights as cisgender people combining information on 18 different policies. It includes the legal status of same-sex marriage.
lgbt_rights_index <- read.csv("data/lgbt-rights-index.csv")
lgbt_rights_index <- lgbt_rights_index |>
filter(Year == 2019) |>
inner_join(select(codelist, iso3c), by = c("Code" = "iso3c")) |>
select(-Year) # all observations are from 2019
str(lgbt_rights_index)'data.frame': 28 obs. of 3 variables:
$ Entity : chr "Austria" "Belgium" "Bulgaria" "Croatia" ...
$ Code : chr "AUT" "BEL" "BGR" "HRV" ...
$ LGBT..Policy.Index: num 8.92 10 4.94 6.96 3.95 ...Column names can be renamed:
lgbt_rights_index <- lgbt_rights_index |>
rename(country_name = Entity,
country_code = Code,
lgbt_policy_index = LGBT..Policy.Index) Gender inequality index
Gender Development and Gender Inequality indexes, developed by the United Nations Development. Retrieved from https://hdr.undp.org/data-center/documentation-and-downloads for the year 2019.
gender_index <- read_xlsx("data/UNDP_gender_indexes.xlsx")
gender_index <- gender_index |>
select(-dimension, -note, -year) |> # empty/useless columns
inner_join(select(codelist, iso3c), by = c("countryIsoCode" = "iso3c"))
gender_index |>
distinct(country) |>
nrow()[1] 28str(gender_index)tibble [560 × 7] (S3: tbl_df/tbl/data.frame)
$ countryIsoCode: chr [1:560] "AUT" "AUT" "AUT" "AUT" ...
$ country : chr [1:560] "Austria" "Austria" "Austria" "Austria" ...
$ indexCode : chr [1:560] "GII" "GDI" "GDI" "GDI" ...
$ index : chr [1:560] "Gender Inequality Index" "Gender Development Index" "Gender Development Index" "Gender Development Index" ...
$ indicatorCode : chr [1:560] "abr" "eys_f" "eys_m" "gdi" ...
$ indicator : chr [1:560] "Adolescent Birth Rate (births per 1,000 women ages 15-19)" "Expected Years of Schooling, female (years)" "Expected Years of Schooling, male (years)" "Gender Development Index (value)" ...
$ value : num [1:560] 5.499 16.451 15.725 0.969 0.053 ...We checked that we have indeed 28 distinct countries in the dataset.
This dataset collects many indicators apart from the indexes values. We are selecting only the Gender Development and Gender Inequality indexes (GDI and GII):
gender_index <- gender_index |>
filter(indicatorCode %in% c("gdi", "gii")) |>
select(-c(indexCode, indicatorCode, indicator)) |> # removing redundant columns
pivot_wider(names_from = index, values_from = value)
colnames(gender_index) <- janitor::make_clean_names(colnames(gender_index)) # cleaning spaces and upper casesAnd then exploring them to see which one is a better fit for modeling and predictions:
summary(gender_index$gender_inequality_index) Min. 1st Qu. Median Mean 3rd Qu. Max.
0.0160 0.0555 0.0890 0.1067 0.1335 0.2390 summary(gender_index$gender_development_index) Min. 1st Qu. Median Mean 3rd Qu. Max.
0.9560 0.9725 0.9855 0.9856 0.9918 1.0230 sd(gender_index$gender_inequality_index)[1] 0.06664423sd(gender_index$gender_development_index)[1] 0.0167627We observe that the second one (Gender Development Index) has a very small range, indicating that most countries have nearly identical scores. This is supported by the standard deviation, which shows that the GII is more spread out than the GDI. Being almost constant, GDI won’t add much value to the analysis. This is likely due to the fact that these indexes are created by the United Nations Development Programme for all countries, so it may not capture the finer differences between EU countries.
cor(gender_index$gender_inequality_index,
gender_index$gender_development_index,
use = "complete.obs")[1] 0.1750589Surprisingly, the two indexes have a very weak positive correlation. While they are not inverse, we interpreted them as measuring opposite things, and had expected a negative correlation. Maybe the correlation coefficient is not useful here because of the low variation of both variables (specially GDI), so ultimately we chose to keep GII and discard GDI.
gender_index <- gender_index |>
select(-gender_development_index)Economist’s Democracy Index
democracy_index <- read_xlsx("data/EIU_democracy_index.xlsx", sheet = 4)
# the ISO codes were lowercase which impedes the join
democracy_index$geo <- toupper(democracy_index$geo)
# filter for 2019 and EU28 countries
democracy_index <- democracy_index |>
filter(time == 2019) |>
inner_join((select(codelist, iso3c)), by = c("geo" = "iso3c"))
# clean var names
names(democracy_index) <- names(democracy_index) %>%
janitor::make_clean_names() %>%
gsub("_eiu$", "", .)
democracy_index <- democracy_index |>
rename(country_code = geo,
country_name = name,
year = time)
str(democracy_index)tibble [28 × 10] (S3: tbl_df/tbl/data.frame)
$ country_code : chr [1:28] "AUT" "BEL" "BGR" "HRV" ...
$ country_name : chr [1:28] "Austria" "Belgium" "Bulgaria" "Croatia" ...
$ year : num [1:28] 2019 2019 2019 2019 2019 ...
$ democracy_index : num [1:28] 82.9 76.4 70.3 65.7 75.9 76.9 92.2 79 92.5 81.2 ...
$ electoral_pluralism_index : num [1:28] 95.8 95.8 91.7 91.7 91.7 95.8 100 95.8 100 95.8 ...
$ government_index : num [1:28] 78.6 82.1 64.3 60.7 64.3 67.9 92.9 78.6 89.3 78.6 ...
$ political_participation_index: num [1:28] 83.3 50 72.2 55.6 66.7 66.7 83.3 66.7 88.9 77.8 ...
$ political_culture_index : num [1:28] 68.8 68.8 43.8 50 68.8 68.8 93.8 68.8 87.5 68.8 ...
$ civil_liberties_index : num [1:28] 88.2 85.3 79.4 70.6 88.2 85.3 91.2 85.3 97.1 85.3 ...
$ change_in_democracy_index : num [1:28] 0 -1.4 0 0 0 ...In this case, we are only keeping the overall index value.
democracy_index <- democracy_index |>
select(country_name, country_code, democracy_index)Joining all country-level data together
country_level_data <- codelist |>
select(iso3c, iso2c) |>
left_join(gdp_data, by = c("iso3c" = "country_code")) |>
# left_join(rural_data, by = c("iso3c" = "country_code")) |> rural population data will probably be discarded
left_join(gender_index, by = c("iso3c" = "country_iso_code")) |>
left_join(lgbt_rights_index, by = c("iso3c" = "country_code")) |>
left_join(democracy_index, by = c("iso3c" = "country_code")) |>
select(-contains("country_")) # removing all duplicated country_name columns that were joined from each data frame
str(country_level_data)tibble [28 × 7] (S3: tbl_df/tbl/data.frame)
$ iso3c : chr [1:28] "AUT" "BEL" "BGR" "HRV" ...
$ iso2c : chr [1:28] "AT" "BE" "BG" "HR" ...
$ gdp_pc_ppp : num [1:28] 64630 60452 27673 35094 46157 ...
$ country : chr [1:28] "Austria" "Belgium" "Bulgaria" "Croatia" ...
$ gender_inequality_index: num [1:28] 0.053 0.048 0.205 0.119 0.235 0.124 0.016 0.092 0.031 0.086 ...
$ lgbt_policy_index : num [1:28] 8.92 10 4.94 6.96 3.95 ...
$ democracy_index : num [1:28] 82.9 76.4 70.3 65.7 75.9 76.9 92.2 79 92.5 81.2 ...Data cleaning
Selecting relevant variables
We are discarding all variables that relate to trade and globalization
as deemed not relevant for our analysis qa. We are also discarding
variables related to energy policies qb.
We have also not considered questions specifically about Roma ex qc8
and qc14 and qc16
Some of the doubts we had:
AGE
x_df <- data_raw |> summarise(mean = mean(qc19), .by = d11)
ggplot(x_df, aes(x = d11, y = mean)) + geom_point()
As relationship seems pretty linear we are going to use the continuous variable for age and there seems to be a clear group (1to4) which is the same used in the variable with 3 categories left, center and right so we will use the 3-categories variable
POLITICAL OPINIONS
x_df <- data_raw |> summarise(mean = mean(qc19), .by = d1)
ggplot(x_df, aes(x = d1, y = mean)) + geom_point() + xlim(1,10)
For political opinions it seems that the relationship is less linear so we will work on the 5 categories cod
MARRIAGE
x_df <- data_raw |> summarise(mean = mean(qc19), .by = d7r1)
ggplot(x_df, aes(x = d7r1, y = mean)) + geom_point() + xlim(1,5)
Of all the possible combinations this one seems the best to highlight differences in our target variable
NATIONALITY
There is no easy way to create an immigrant dummy by checking whether
someone does not have the nationality of the country in which he is
being interviewed for the survey. So we are just going to use q1_29 as
a dummy for whether someone owns a non-EU nationality
POLITICAL INTEREST
Using only polintr as a summary of the whole d71 question about how
strong is your interest in politics in various domains
EXPERIENCED DISCRIMINATION
For the questions about whether you have experienced discrimination
qc2_ I am keeping only qc2_15 which is a binary on whether you have
experienced any discrimination or not and I am not keeping the other
categories that allowed us to understand if you had experienced
discrimination on the basis of a particular motive. We can probably
assume that if a person is a part of a specific minority (info from
sd2) and is being discriminated is because of being part of that
minority (at least in most cases), therefore it felt like information we
already had (and which we can easily put in our regression using
interaction effects)
PERCIEVED DISCRIMINATION in country
This is a question (qc1) about how widespread you perceived
discrimination is in your country. It is a rather peculiar question
because it asks individuals for perception at the country level. I think
it might be more useful (by aggregating results by country) to use it to
build a country level indicator of perceived discrimination against
certain minorities that are of our interest rather than use it as an
individual level variable. So I will keep them out of the dataset for
now
For the same reason I am also discarding qc4 that asks whether in your
country you feel like candidates with certain characteristics would be
at a disadvantage in the recruitment process. It still basically asks
about perceived discrimination at the country level.
And the same reasoning also applies to qc7 which asks if efforts
towards reducing discrimination are effective in your country.
HOW DISCRIMINATORY ARE YOU score
I use qc12 and qc13 to build a score from 1 to 10 of how
discriminatory are you against certain minorities. I am building the
score for each minority and then we can decide later if some are
irrelevant.
Note for some categories this score is a bit stupid (ex. voting for whether you would feel uncomfortable if your child was in a love relationship with a old person would give you a high racist score against old people, this is an example of some of the categories for which it is worth excluding the index)
We can also further aggregate to obtain just one score (or obtain religious/ethnic score etc.).
qc6 also asks about discriminatory behaviors, but is about elected
public official, it does not ask about a situation that impacts you
personally. It also uses different categories for minorities therefore I
prefer to use qc12 and qc13 rather than qc6.
SUPPORTIVE OF LGBTQ RIGHTS INDEX
Using qc15 we can again build an index for how supportive of lgbtq
rights a person is.
I again choose to take the mean across the different answers but we could also use median/mode if we think is better
We could also use qc18 to try to capture anti lgbtq sentiment, but I
preferred qc15 as it seemed more straightforward (I therefore deleted
qc18, but we can put it back if useful).
MY VOICE COUNTS
I guess that people that feel alienated from society and politics might
be less likely to support lgbtq rights so I took the mean of d72
question which asked whether you felt like your voice mattered.
OTHERS
qc11 is a strange question feels useless to me, I removed it.
I also removed qc9 as I don’t really know what to do with it and
qc17.
data <- data_raw |>
select(serialid, # unique identifier
isocntry, # 2 digit country code
d11, # age variables
q1_29, # nationality of interviewee. options given: EU28+Other+DK, using only other = outside of EU
d70, #life satisfaction
polintr, # political interest index (summarizes d71 questions)
starts_with("sd1"), # friends that are minority groups
starts_with("sd2"), # are you part of a minority
sd3, # religion
qc2_15, # experienced discrimination yourself
qc3, # where discrimination took place
starts_with("qc5"), # actions against discrimination
qc10, # how would you report discrimination
starts_with("qc12"), # feelings about colleagues being minority
starts_with("qc13"), # feelings about kid being in a relationship with minority
starts_with("qc15"), # opinions about lgbtqi
qc19, # target variable transgender
qc20, # non-binary genders in documents
d1r1, # political ideology
d7r1, # marital status
d10, # gender binary
d8, # eduaction
d15a_r2, # current occupation (discarded previous occupation d15b)
d25, # rural vs urban
d43t, # phones availiabilty
d60, # financial stress (paying bills)
netuse, # internet index
d63, # social class
starts_with("d72"), # my voice counts
)
paradata <- data_raw |>
select(serialid, # to match it with the other data
p2, p3, p3r, p4, p5) # paradata)Removing some of the previously selected variables
sd2_7 to sd2_10: these are possible answer deemed irrelevant to the
question about yourself being part of the following minorities: sd2_7
other minorities (I don’t know what other relevant minorities could be
there), sd2_8 not part of minorities (can be deducted from the rest),
sd2_9 refusal to respond, sd2_10 DK answers sd2t summary binary
variable for being part of any minority (we are going to keep the more
specific one)
I also remove qc12_nr as I prefer to work on the full variable instead
of the recoded version with less categories. Same for qc13 and qc18
data <- data |>
# Keep in mind that sd2t does not have NAs so we might want to use that instead of the more specific ones
select(-c(sd2_7, sd2_8, sd2_9, sd2_10, sd2t)) |>
select(-(starts_with("qc12") & ends_with("r"))) |>
select(-(starts_with("qc13") & ends_with("r"))) |>
select(-(starts_with("qc18") & ends_with("r")))Check overall data quality
All columns are numeric columns, the only one which is not is isocntry
data |>
select(where(~ !is.numeric(.)))# A tibble: 27,438 × 1
isocntry
<chr>
1 BE
2 BE
3 BE
4 BE
5 BE
6 BE
7 BE
8 BE
9 BE
10 BE
# ℹ 27,428 more rowsMost columns do not have explicit NAs
Exploiting the fact that the .dta files has attributes (labels) for all its columns.
If we search for attr(colname, "label") you get back the original long
name of the variable
If we instead search for attr(colname, "labels") you get back all the
possible encoding levels of the variable (ex.1,2,3,4 etc.) and by doing
names(attr(colname, "labels")) you get back the actual meaning of
those numbers (ex. 1 = “Yes”, 2 = “No”, etc.)
Will now look into the labels for the different levels that our factor variables can take:
attr(data$d70, "labels") Very satisfied Fairly satisfied Not very satisfied
1 2 3
Not at all satisfied DK
4 5 [1] "Very satisfied" "Fairly satisfied"
[3] "Not very satisfied" "Not at all satisfied"
[5] "DK" # A tibble: 5 × 2
name_labels labels
<chr> <dbl>
1 Very satisfied 1
2 Fairly satisfied 2
3 Not very satisfied 3
4 Not at all satisfied 4
5 DK 5# Create a list of tibbles containing the labels and their associated name for each variable
list_label_tibbles <-
#Applies a function across all columns of a df and returns results as a list
lapply(names(data), function(col_name) {
labels <- attr(data[[col_name]], "labels") # Extract labels
name_labels <- names(labels) # Extract label names
# Create tibble with the extracted data only if labels exist
if (!is.null(labels)) {
tibble(name_labels = name_labels, labels = labels)}
else {NULL} # Returns a NULL element for columns without labels
})
# Giving to each element of the list as name the name of the variable
list_label_tibbles <- setNames(list_label_tibbles, names(data))
# For example
list_label_tibbles$d70# A tibble: 5 × 2
name_labels labels
<chr> <dbl>
1 Very satisfied 1
2 Fairly satisfied 2
3 Not very satisfied 3
4 Not at all satisfied 4
5 DK 5Right column is what appears in our data (as a number). Left column is the label that we must assign to that number when we factorize
Cleaning
Initial cleaning and pre-processing
Recoding together Germany East and West because we are running analysis at the country level and they are coded separately.
unique(data$isocntry) [1] "BE" "DK" "GR" "ES" "FI" "FR" "IE" "IT" "LU"
[10] "NL" "AT" "PT" "SE" "DE-W" "DE-E" "GB" "BG" "CY"
[19] "CZ" "EE" "HU" "LV" "LT" "MT" "PL" "RO" "SK"
[28] "SI" "HR" Separating variables for which I can use the attribute labels to factorize them and the variables for which this strategy cannot be used
data <- data |>
rename(friends_trans = sd1_7)
non_factor_variables <- c("serialid", "tnscntry", "isocntry", "d11", "q1_29",
names(data)[startsWith(names(data), "sd1_")],
names(data)[startsWith(names(data), "sd2_")],
names(data)[startsWith(names(data), "qc5_")],
names(data)[startsWith(names(data), "qc12_")],
names(data)[startsWith(names(data), "qc13_")],
names(data)[startsWith(names(data), "qc15_")],
names(data)[startsWith(names(data), "d72_")],
"d8", "opls")
factor_variables <- setdiff(names(data), non_factor_variables)Correctly encoding the factor variables that do not need any further cleaning
# Converting them to factors and assign them their labels automatically
data <- data |>
mutate(across(all_of(factor_variables), labelled::to_factor))
# Turning DK into NAs for all the factor variables
data <- data |>
mutate(across(all_of(factor_variables), ~ fct_na_level_to_value(., extra_levels = "DK")))
# Converting to numeric the variables that should be numeric
# They are already numeric but they carry with them some labels as well that only confuse us, by doing this I remove the labels
data <- data |>
mutate(age = as.numeric(d11),
years_edu = as.numeric(d8)) |>
# Recoding correctly d8 education variable according to unique(data_raw$d11))
mutate(years_edu = case_when(
years_edu %in% c(0, 99) ~ NA, # Refusal and DK as NAs
years_edu == 97 ~ 0, # No full time education = 0
years_edu == 98 ~ age, # still studying = age
TRUE ~ years_edu)) |>
select(-c(d11, d8))
# Converting q1_29 to factor without assigning labels (1 if non-Eu nationality, 0 if EU nationality)
# Same for sd2_
data <- data |>
mutate(nonEU_national = as.factor(q1_29),
across(starts_with("sd2_"), ~ as.factor(.x))) |>
select(-q1_29)Dealing with the other variables on which we do some further pre-processing (feature engineering)
# Creating a variable that counts the number of different minority groups a person has acquaintances with
data <- data |>
mutate(across(starts_with("sd1"), ~ if_else(.x == 1, 1, 0))) |>
mutate(n_friends_minorities = sd1_1+sd1_2+sd1_3+sd1_4+sd1_5+sd1_6+sd1_8) |>
relocate(n_friends_minorities, .before="sd1_1") |>
select(-starts_with("sd1"))# Creating a variable that counts the number of actions against discrimination that you have taken in the last year
data <- data |>
mutate(across(starts_with("qc5"), ~ if_else(.x == 1, 1, 0))) |>
mutate(n_actions_against_discri = qc5_1+qc5_2+qc5_3+qc5_4) |>
relocate(n_actions_against_discri, .after="qc3") |>
select(-starts_with("qc5"))# Building a discriminatory score
data <- data |>
# Coding as NAs "it depends" and "DK"
mutate(across(starts_with("qc12"), ~ if_else(.x >= 12, NA, .x))) |>
mutate(across(starts_with("qc13"), ~ if_else(.x >= 12, NA, .x))) |>
# Coding as 5 responses = indifferent
mutate(across(starts_with("qc12"), ~ if_else(.x == 11, 5, .x))) |>
mutate(across(starts_with("qc13"), ~ if_else(.x == 11, 5, .x))) |>
# Modifying such that higher is more discriminatory
mutate(roma_discri = 11 - rowMeans(cbind(qc12_1, qc13_1), na.rm = TRUE),
black_discri = 11 - rowMeans(cbind(qc12_2, qc13_2), na.rm = TRUE),
asian_discri = 11 - rowMeans(cbind(qc12_3, qc13_3), na.rm = TRUE),
white_discri = 11 - rowMeans(cbind(qc12_4, qc13_4), na.rm = TRUE),
jewish_discri = 11 - rowMeans(cbind(qc12_5, qc13_5), na.rm = TRUE),
muslim_discri = 11 - rowMeans(cbind(qc12_6, qc13_6), na.rm = TRUE),
buddihst_discri = 11 - rowMeans(cbind(qc12_7, qc13_7), na.rm = TRUE),
christian_discri = 11 - rowMeans(cbind(qc12_8, qc13_8), na.rm = TRUE),
atheist_discri = 11 - rowMeans(cbind(qc12_9, qc13_9), na.rm = TRUE),
lgb_discri = 11 - rowMeans(cbind(qc12_10, qc13_10), na.rm = TRUE),
trans_discri = 11 - rowMeans(cbind(qc12_11, qc13_11), na.rm = TRUE),
intersex_discri = 11 - rowMeans(cbind(qc12_12, qc13_12), na.rm = TRUE),
disability_discri = 11 - rowMeans(cbind(qc12_13, qc13_13), na.rm = TRUE),
young_discri = 11 - rowMeans(cbind(qc12_14, qc13_14), na.rm = TRUE),
old_discri = 11 - rowMeans(cbind(qc12_15, qc13_15), na.rm = TRUE)) |>
select(-starts_with("qc12")) |>
select(-starts_with("qc13"))
# I am deleting the discrimination index against young and old people
# This is because one of the question is: how comfortable you would feel if one of your children was in a love relationship with a person from group x.
# It is totally acceptable that people would not feel comfortable with their kid dating an old person without that meaning that they are being discriminatory against old people
data <- data |>
select(-c("old_discri", "young_discri"))# Supportive/anti lbtq rights index
data <- data |>
mutate(across(starts_with("qc15"), ~ if_else(.x == 5, NA, .x))) |>
mutate(antilgbtq_rights = round(rowMeans(cbind(qc15_1, qc15_2, qc15_3), na.rm = TRUE), 2)) |>
select(-starts_with("qc15"))
# Scale of 1 to 4, 1 = supportive, 4 = homophobic# My voice counts index
data <- data |>
mutate(across(starts_with("d72"), ~ if_else(.x > 4, NA, .x))) |>
mutate(social_alienation = rowMeans(cbind(d72_1, d72_2), na.rm = TRUE)) |>
select(-starts_with("d72"))
# The higher the more people think their voice does not matterThis should be our final selection of variables.
We still need to rename them appropriately and check that all the NAs are correctly encoded by looking at the summary.
Further cleaning
Rename columns appropriately
data <- data |>
rename(
country = isocntry,
life_sat = d70,
ethnic_minority = sd2_1,
skincolor_minority = sd2_2,
religious_minority = sd2_3,
roma_minority = sd2_4,
sexual_minority = sd2_5,
disability_minority = sd2_6,
religion = sd3,
disc = qc2_15,
disc_where = qc3,
disc_contact = qc10,
trans_docs = qc19,
gender_docs = qc20,
left_right = d1r1,
marital_status = d7r1,
gender = d10,
occupation = d15a_r2,
community = d25,
phone_access = d43t,
bill_issues = d60,
internet_use = netuse,
social_class = d63
) Now, we will transform the variable disc, which was originally coded in a negative way (1 = “Not mentioned”, 2 = “No, you haven’t been discriminated against”), into a positive dummy variable to make its interpretation more straightforward. The variable is 1 if a person has been subject to discrimination
Move the variables around to have a ordered dataframe
# Relocating to have a ordered df
data <- data |>
relocate(c("age", "gender", "years_edu","community", "marital_status", "occupation", "social_class", "religion", "nonEU_national", "phone_access", "bill_issues", "internet_use"), .after = country) |>
relocate(c("left_right", "social_alienation"), .after = polintr) |>
relocate(c("friends_trans", "n_friends_minorities", "n_actions_against_discri"), .after = gender_docs)
# Assigning labels to columns which have a difficult meaning
attr(data$gender, "label") <- NULL
attr(data$nonEU_national, "label") <- "OWNS A NON-EU NATIONALITY"
attr(data$social_alienation, "label") <- "HIGHER -> THINK THEIR VOICE DOESN'T MATTER"
attr(data$ethnic_minority, "label") <- "ARE YOU PART OF X MINORITY"
attr(data$skincolor_minority, "label") <- "ARE YOU PART OF X MINORITY"
attr(data$religious_minority, "label") <- "ARE YOU PART OF X MINORITY"
attr(data$roma_minority, "label") <- "ARE YOU PART OF X MINORITY"
attr(data$sexual_minority, "label") <- "ARE YOU PART OF X MINORITY"
attr(data$disability_minority, "label") <- "ARE YOU PART OF X MINORITY"
attr(data$disability_minority, "label") <- "ARE YOU PART OF X MINORITY"
attr(data$disability_minority, "label") <- "ARE YOU PART OF X MINORITY"
attr(data$suffered_discr, "label") <- "HAVE YOU BEEN SUBJECT TO DISCRIMINATION"
attr(data$n_friends_minorities, "label") <- "YOU KNOW PEOPLE FROM # NUMBER OF DIFFERENT MINORITES"
attr(data$n_actions_against_discri, "label") <- "YOU HAVE DONE # NUMBER OF DIFFERENT ACTIONS TO FIGHT DISCRIMINATIONS"
attr(data$roma_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$black_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$asian_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$white_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$jewish_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$muslim_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$buddihst_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$christian_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$atheist_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$atheist_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$lgb_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$trans_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$intersex_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$disability_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$antilgbtq_rights, "label") <- "HIGHER -> THEY OPPOSE MORE RIGHTS TO LGBTQ"summary(data) serialid country age gender
Min. : 1 Length:27438 Min. :15.00 Man :12492
1st Qu.: 6860 Class :character 1st Qu.:37.00 Woman:14946
Median :13720 Mode :character Median :53.00
Mean :13720 Mean :51.56
3rd Qu.:20579 3rd Qu.:66.00
Max. :27438 Max. :98.00
years_edu community
Min. : 0.00 Rural area or village : 8776
1st Qu.:17.00 Small or middle sized town:10767
Median :18.00 Large town : 7881
Mean :19.66 NA's : 14
3rd Qu.:22.00
Max. :90.00
NA's :387
marital_status
(Re-)Married (1-4 in d7) :14673
Single living with partner (5-8 in d7): 3321
Single (9-10 in d7) : 4314
Divorced or separated (11-12 in d7) : 2243
Widow (13-14 in d7) : 2712
Other (SPONT.) : 107
Refusal (SPONT.) : 68
occupation
Retired (4 in d15a) :8791
Manual workers (15 to 18 in d15a) :5883
Other white collars (13 or 14 in d15a):3536
Managers (10 to 12 in d15a) :2911
Self-employed (5 to 9 in d15a) :1979
Students (2 in d15a) :1676
(Other) :2662
social_class
The middle class of society :13068
The working class of society : 7233
The lower middle class of society: 4070
The upper middle class of society: 1889
None (SPONTANEOUS) : 229
(Other) : 389
NA's : 560
religion nonEU_national
Catholic :11198 0:27316
Orthodox Christian : 4016 1: 122
Non believer or agnostic: 3694
Protestant : 3031
Atheist : 2109
(Other) : 3220
NA's : 170
phone_access bill_issues
Mobile only :14555 Most of the time : 2054
Landline only : 802 From time to time : 6538
Landline & mobile:11576 Almost never/never:18467
No telephone : 505 Refusal (SPONT.) : 379
internet_use life_sat
Everyday/Almost everyday :19900 Very satisfied : 7242
Two or three times a week : 1701 Fairly satisfied :15356
About once a week : 434 Not very satisfied : 3736
Two or three times a month: 164 Not at all satisfied: 1002
Less often : 350 NA's : 102
Never/No access : 4311
No Internet access at all : 578
polintr left_right social_alienation
Strong : 4644 (1 - 4) Left :7082 Min. :1.000
Medium :13701 (5 - 6) Centre:9313 1st Qu.:1.500
Low : 4387 (7 -10) Right :6354 Median :2.000
Not at all: 4706 DK/Refusal :4689 Mean :2.329
3rd Qu.:3.000
Max. :4.000
NA's :1000
ethnic_minority skincolor_minority religious_minority roma_minority
0:26603 0:26923 0:26416 0:27001
1: 835 1: 515 1: 1022 1: 437
sexual_minority disability_minority suffered_discr
0:27006 0:26756 0:23150
1: 432 1: 682 1: 4288
disc_where
In a public space : 893
At work : 788
When looking for a job : 642
At a café, restaurant, bar or nightclub : 322
By healthcare personnel (e.g. a receptionist, nurse or doctor): 308
(Other) : 1054
NA's :23431
disc_contact
The police :8769
A friend or family member :5386
An equalities body or ombudsman (SPECIFY THE NAME ACCORDING TO THE COUNTRY):3795
A lawyer :2329
Courts :1225
(Other) :3601
NA's :2333
trans_docs gender_docs friends_trans
Yes :14463 Yes :10856 Yes : 2644
No : 9695 No :13395 No :23520
NA's: 3280 NA's: 3187 Refusal (SPONTANEOUS): 306
NA's : 968
n_friends_minorities n_actions_against_discri roma_discri
Min. :0.000 Min. :0.0000 Min. : 1.000
1st Qu.:1.000 1st Qu.:0.0000 1st Qu.: 1.500
Median :3.000 Median :0.0000 Median : 4.500
Mean :3.029 Mean :0.3855 Mean : 4.631
3rd Qu.:5.000 3rd Qu.:0.0000 3rd Qu.: 7.000
Max. :7.000 Max. :4.0000 Max. :10.000
NA's :757
black_discri asian_discri white_discri jewish_discri
Min. : 1.000 Min. : 1.000 Min. : 1.000 Min. : 1.00
1st Qu.: 1.000 1st Qu.: 1.000 1st Qu.: 1.000 1st Qu.: 1.00
Median : 3.000 Median : 2.500 Median : 1.000 Median : 2.00
Mean : 3.579 Mean : 3.387 Mean : 1.785 Mean : 3.18
3rd Qu.: 5.500 3rd Qu.: 5.500 3rd Qu.: 2.000 3rd Qu.: 5.00
Max. :10.000 Max. :10.000 Max. :10.000 Max. :10.00
NA's :542 NA's :592 NA's :403 NA's :603
muslim_discri buddihst_discri christian_discri atheist_discri
Min. : 1.000 Min. : 1.000 Min. : 1.000 Min. : 1.000
1st Qu.: 1.000 1st Qu.: 1.000 1st Qu.: 1.000 1st Qu.: 1.000
Median : 4.000 Median : 3.000 Median : 1.000 Median : 1.500
Mean : 4.363 Mean : 3.576 Mean : 1.904 Mean : 2.802
3rd Qu.: 6.500 3rd Qu.: 5.500 3rd Qu.: 2.000 3rd Qu.: 4.000
Max. :10.000 Max. :10.000 Max. :10.000 Max. :10.000
NA's :662 NA's :761 NA's :414 NA's :517
lgb_discri trans_discri intersex_discri disability_discri
Min. : 1.000 Min. : 1.000 Min. : 1.000 Min. : 1.000
1st Qu.: 1.000 1st Qu.: 2.000 1st Qu.: 1.500 1st Qu.: 1.000
Median : 4.000 Median : 5.000 Median : 5.000 Median : 2.500
Mean : 4.399 Mean : 4.934 Mean : 4.825 Mean : 2.977
3rd Qu.: 6.500 3rd Qu.: 7.500 3rd Qu.: 7.500 3rd Qu.: 4.500
Max. :10.000 Max. :10.000 Max. :10.000 Max. :10.000
NA's :536 NA's :1081 NA's :1331 NA's :585
antilgbtq_rights
Min. :1.000
1st Qu.:1.000
Median :2.000
Mean :2.147
3rd Qu.:3.000
Max. :4.000
NA's :791 Our dataset seems quite balanced across the different countries
data |> count(country)# A tibble: 28 × 2
country n
<chr> <int>
1 AT 1027
2 BE 1028
3 BG 1032
4 CY 503
5 CZ 1008
6 DE 1537
7 DK 1004
8 EE 1003
9 ES 1005
10 FI 1003
# ℹ 18 more rowsAlthough some levels of occupation have more observations than others,
we have enough observations for each level so we do not need to
aggregate over different levels for the variable occupation
data |> count(occupation)# A tibble: 8 × 2
occupation n
<fct> <int>
1 Self-employed (5 to 9 in d15a) 1979
2 Managers (10 to 12 in d15a) 2911
3 Other white collars (13 or 14 in d15a) 3536
4 Manual workers (15 to 18 in d15a) 5883
5 House persons (1 in d15a) 1358
6 Unemployed (3 in d15a) 1304
7 Retired (4 in d15a) 8791
8 Students (2 in d15a) 1676Very few people declare themselves to be the higher class of society, nonetheless we keep this level because it makes sense
data |> count(social_class)# A tibble: 9 × 2
social_class n
<fct> <int>
1 The working class of society 7233
2 The lower middle class of society 4070
3 The middle class of society 13068
4 The upper middle class of society 1889
5 The higher class of society 157
6 Other (SPONTANEOUS) 59
7 None (SPONTANEOUS) 229
8 Refusal (SPONTANEOUS) 173
9 <NA> 560Given the low number of observations in some categories of the variable
religion and the high number of categories we opt to aggregate some of
them, otherwise we risk too much noise in our models.
data |> count(religion)# A tibble: 16 × 2
religion n
<fct> <int>
1 Catholic 11198
2 Orthodox Christian 4016
3 Protestant 3031
4 Other Christian 1183
5 Jewish 58
6 Muslim - Shia 77
7 Muslim - Sunni 178
8 Other Muslim 137
9 Sikh 13
10 Buddhist 58
11 Hindu 32
12 Atheist 2109
13 Non believer or agnostic 3694
14 Other 1171
15 Refusal (SPONTANEOUS) 313
16 <NA> 170# Checking if the means of groups we are going to aggregate are similar
data |>
mutate(trans_docs=as.numeric(trans_docs)) |>
summarise(mean = mean(trans_docs, na.rm=TRUE), .by = religion) |>
arrange(mean)# A tibble: 16 × 2
religion mean
<fct> <dbl>
1 Sikh 1.25
2 Atheist 1.27
3 Non believer or agnostic 1.28
4 Protestant 1.30
5 Buddhist 1.33
6 Other 1.37
7 Jewish 1.38
8 Other Christian 1.43
9 Catholic 1.43
10 Hindu 1.44
11 Muslim - Shia 1.45
12 <NA> 1.45
13 Other Muslim 1.49
14 Refusal (SPONTANEOUS) 1.49
15 Muslim - Sunni 1.54
16 Orthodox Christian 1.58# We are going to group together atheist with agnostic
# We are also going to put sikh, buddhists, jewish and hindu into the other category
# Finally we are going to group together all muslims
data <- data |>
mutate(religion = fct_collapse(religion,
"Non-believers" = c("Atheist", "Non believer or agnostic"),
"Other" = c("Sikh", "Buddhist", "Jewish", "Hindu", "Other"),
"Muslim" = c("Muslim - Shia", "Muslim - Sunni", "Other Muslim")))
#This is what we end up with
data |> count(religion)# A tibble: 9 × 2
religion n
<fct> <int>
1 Catholic 11198
2 Orthodox Christian 4016
3 Protestant 3031
4 Other Christian 1183
5 Other 1332
6 Muslim 392
7 Non-believers 5803
8 Refusal (SPONTANEOUS) 313
9 <NA> 170Recoding missing values
Now we will substitute de “Refusal” answers in the remaining variables
as NAs. If the respondent refuses to answer it’s equivalent to not
knowing his or her answer. We exclude friends_trans because for that
category it could be worth analyzing refusal.
factor_variables <- names(data)[sapply(data, is.factor)]
data <- data %>%
mutate(across(
all_of(setdiff(factor_variables, "friends_trans")), # Exclude "friends_trans"
~ {
# Look for levels that contain "REFUSAL"
refusal_levels <- grep("REFUSAL", levels(.), value = TRUE, ignore.case = TRUE)
# If there are levels containing "REFUSAL"
if (length(refusal_levels) > 0) {
# Convert in NA
fct_recode(., NULL = refusal_levels)
}
# if not remain without changes
else {
.
}
}
))
# Mutate NONE level of social class to NA
data <- data %>%
mutate(social_class = fct_recode(social_class, NULL = "None (SPONTANEOUS)"))
# We turn marital_status level OTHER into NAs, as it is difficult to give it any other meaning. Same for social class
data <- data %>%
mutate(marital_status = fct_recode(marital_status, NULL = "Other (SPONT.)"),
social_class = fct_recode(social_class, NULL = "Other (SPONTANEOUS)")) 
The total number of missing observations is quite low (4%) so missing data should not be a huge problem
Given the high percentage of missing values we delete disc_where. This
variable was expected to have a high percentage of missingness as it is
a question that applies only to people that have been subject to
discrimination. So it is not of huge importance
The variable with the second highest number of missing data is
left_right, given the importance of this variable it is probably worth
to impute those values.
Next there are the variables trans_docs and gender_docs which are
respectively our target variable and a closely related variable
Then there is disc_contact which will be deleted as well, given that
it does not add meaningful information to our analysis
Exploratory Data Analysis
Plotting the distribution of the numeric variables
library(e1071)
# Identify numeric variables
numeric_vars <- names(data)[sapply(data, is.numeric)]
numeric_vars <- numeric_vars[numeric_vars != "serialid"]
plot_histogram(data |> select(all_of(numeric_vars)))
# Creating histogramas y calculating skweness
for (var in numeric_vars) {
p <- ggplot(data, aes(x = .data[[var]])) +
geom_histogram(binwidth = 1, fill = "blue", color = "black") +
labs(title = paste("Histogram of", var), x = var, y = "Count") +
theme_minimal()
print(p)}
Analysis of individual-level variables
We must keep in mind our Target variable is qc19 “Do you think that
transgender persons should be able to change their civil documents to
match their inner gender identity?”
data_percent <- data |>
mutate(trans_docs = fct_na_value_to_level(trans_docs, "Don't Know")) |>
group_by(trans_docs) |>
summarise(count = n()) |>
mutate(percentage = count / sum(count) * 100)
ggplot(data_percent, aes(x = trans_docs, y = percentage, fill = trans_docs)) +
geom_bar(stat = "identity") +
geom_text(aes(label = sprintf("%.1f%%", percentage)),
vjust = -0.5, size = 4, color = "black") +
scale_y_continuous(labels = scales::percent_format(scale = 1)) +
labs(
title = "Overall distribution of support for trans people to change \ntheir gender in civil documents",
x = "Support for Transgender Rights",
y = "Percentage"
) +
theme_minimal() +
theme(legend.position = "none")
Taking a look to our variable of interest alone, we see how the 52.7% of our sample are in favor of trans people to change their gender in their civil documents. However, there is also a significant opposition (35,3%), and a 12% who answered “Don’t know”. We will try to explore this distribution along the variables we consider to be most important for our analysis.
Sociodemographic variables
Gender
data_summary <- data |>
mutate(trans_docs = fct_na_value_to_level(trans_docs, "Don't Know")) |>
count(trans_docs, gender, name = "n") |>
group_by(gender) |>
mutate(percentage = n / sum(n))
ggplot(data_summary, aes(x = gender, y = percentage, fill = trans_docs)) +
geom_bar(stat = "identity", position = "fill") +
geom_text(aes(label = scales::percent(percentage, accuracy = 1)),
position = position_stack(vjust = 0.5), size = 4) +
scale_y_continuous(labels = percent_format()) +
scale_fill_manual(
values = c("Yes" = "#2ECC71", "No" = "#E74C3C", "Don't Know" = "#3498DB")
) +
labs(
title = "Support for being able to change gender on official documents",
x = "Gender",
y = "Proportion of Responses",
fill = ""
) +
coord_flip() +
theme_minimal()+
theme(
panel.grid = element_blank(),
axis.text.x = element_blank(),
axis.ticks.x = element_blank()
)
# Crear una tabla de contingencia
contingency_table <- table(data$gender, data$trans_docs)
# Realizar la prueba de chi-cuadrado
chisq_test <- chisq.test(contingency_table)
print(chisq_test)
Pearson's Chi-squared test with Yates' continuity correction
data: contingency_table
X-squared = 92.715, df = 1, p-value < 2.2e-16Men exhibit a lower percentage of favorable or dk responses and a higher rate of rejection compared to women. There is a statistically significant association between gender and our target variable, being women more supportive
Age
data |>
mutate(trans_docs = fct_na_value_to_level(trans_docs, "Don't Know")) |>
mutate(age_bin = cut(age, breaks = seq(min(age, na.rm = TRUE), max(age, na.rm = TRUE), by = 10), include.lowest = TRUE)) |>
# There are 4 observations above 95 y.o. that do not fall within any of the previously difined bins. Given their low number we drop them
drop_na(age_bin) |>
count(age_bin, trans_docs) |>
group_by(age_bin) |>
mutate(percentage = n / sum(n) * 100) |>
ggplot(aes(x = age_bin, y = percentage, fill = trans_docs)) +
geom_bar(stat = "identity", position = "stack") +
coord_flip() +
labs(x = "Age Bins", y = "Proportion of responses", fill = "",
title = "Support for being able to change gender on official documents") +
scale_fill_manual(
values = c("Yes" = "#2ECC71", "No" = "#E74C3C", "Don't Know" = "#3498DB")
) +
theme_minimal() +
theme(
panel.grid = element_blank(),
axis.text.x = element_blank(),
axis.ticks.x = element_blank()
)
Younger people seem more likely to support the right for transgender people to have their gender changed on official documents.
We also notice a big increase of NAs for older people, meaning older people are less likely to respond to this question (because of unfamiliarity with the topic maybe)
So how would that distribution look if we get rid of NAs
data |>
drop_na(trans_docs) |>
mutate(age_bin = cut(age, breaks = seq(min(age, na.rm = TRUE), max(age, na.rm = TRUE), by = 10), include.lowest = TRUE)) |>
# There are 4 observations above 95 y.o. that do not fall within any of the previously difined bins. Given their low number we drop them
drop_na(age_bin) |>
count(age_bin, trans_docs) |>
group_by(age_bin) |>
mutate(percentage = n / sum(n) * 100) |>
ggplot(aes(x = age_bin, y = percentage, fill = trans_docs)) +
geom_bar(stat = "identity", position = "stack") +
coord_flip() +
labs(x = "Age Bins", y = "Proportion of responses", fill = "",
title = "Support for being able to change gender on official documents") +
scale_fill_manual(
values = c("Yes" = "#2ECC71", "No" = "#E74C3C", "Don't Know" = "#3498DB")
) +
theme_minimal() +
theme(
panel.grid = element_blank(),
axis.text.x = element_blank(),
axis.ticks.x = element_blank()
)
We see that differences among age groups are not so evident anymore.
Religiosity
We have two variables related to religiosity: religion (the religious affiliation professed by the respondent) and religious_minority (whether or not the respondent belongs to a religious minority group).
For the first one it’s better to show a cross table instead of a plot, since there are a lot of categories
CrossTable(data$religion, data$trans_docs,
digits = 2,
expected = FALSE,
asresid = TRUE,
chisq = TRUE,
prop.chisq = FALSE,
format = "SPSS")
Cell Contents
|-------------------------|
| Count |
| Row Percent |
| Column Percent |
| Total Percent |
| Adj Std Resid |
|-------------------------|
Total Observations in Table: 23792
| data$trans_docs
data$religion | Yes | No | Row Total |
-------------------|-----------|-----------|-----------|
Catholic | 5605 | 4241 | 9846 |
| 56.93% | 43.07% | 41.38% |
| 39.27% | 44.55% | |
| 23.56% | 17.83% | |
| -8.09 | 8.09 | |
-------------------|-----------|-----------|-----------|
Orthodox Christian | 1421 | 1959 | 3380 |
| 42.04% | 57.96% | 14.21% |
| 9.96% | 20.58% | |
| 5.97% | 8.23% | |
| -22.99 | 22.99 | |
-------------------|-----------|-----------|-----------|
Protestant | 1866 | 807 | 2673 |
| 69.81% | 30.19% | 11.23% |
| 13.07% | 8.48% | |
| 7.84% | 3.39% | |
| 11.00 | -11.00 | |
-------------------|-----------|-----------|-----------|
Other Christian | 597 | 449 | 1046 |
| 57.07% | 42.93% | 4.40% |
| 4.18% | 4.72% | |
| 2.51% | 1.89% | |
| -1.97 | 1.97 | |
-------------------|-----------|-----------|-----------|
Other | 764 | 446 | 1210 |
| 63.14% | 36.86% | 5.09% |
| 5.35% | 4.68% | |
| 3.21% | 1.87% | |
| 2.30 | -2.30 | |
-------------------|-----------|-----------|-----------|
Muslim | 159 | 160 | 319 |
| 49.84% | 50.16% | 1.34% |
| 1.11% | 1.68% | |
| 0.67% | 0.67% | |
| -3.72 | 3.72 | |
-------------------|-----------|-----------|-----------|
Non-believers | 3860 | 1458 | 5318 |
| 72.58% | 27.42% | 22.35% |
| 27.05% | 15.32% | |
| 16.22% | 6.13% | |
| 21.28 | -21.28 | |
-------------------|-----------|-----------|-----------|
Column Total | 14272 | 9520 | 23792 |
| 59.99% | 40.01% | |
-------------------|-----------|-----------|-----------|
Statistics for All Table Factors
Pearson's Chi-squared test
------------------------------------------------------------
Chi^2 = 973.2956 d.f. = 6 p = 5.330102e-207
Minimum expected frequency: 127.6429 Out of all observations Catholic, non-believers, Orthodox Christians and Protestants sum up to the 81.04% of our sample, being the rest underrepresented.
data_summary <- data |>
count(trans_docs, religious_minority, name = "n") |>
group_by(religious_minority) |>
mutate(percentage = n / sum(n))
ggplot(data_summary, aes(x = trans_docs, y = percentage, fill = religious_minority)) +
geom_bar(stat = "identity", position = "dodge") +
geom_text(aes(label = scales::percent(percentage, accuracy = 1)),
position = position_dodge(width = 0.9), vjust = -0.2, size = 4) +
scale_y_continuous(labels = percent_format()) +
labs(
title = "Distribution of support by religious minority",
x = "Support for trans people changing their civil documents",
y = "Percentage within religious_minority",
fill = "religious_minority"
) +
theme_minimal()
Ideology
data_summary <- data |>
count(trans_docs, left_right, name = "n") |>
group_by(left_right) |>
mutate(percentage = n / sum(n))
ggplot(data_summary, aes(x = trans_docs, y = percentage, fill = left_right)) +
geom_bar(stat = "identity", position = "dodge") +
geom_text(aes(label = scales::percent(percentage, accuracy = 1)),
position = position_dodge(width = 0.9), vjust = -0.2, size = 4) +
scale_y_continuous(labels = percent_format()) +
labs(
title = "Distribution of support by ideology",
x = "Support for trans people changing their civil documents",
y = "Percentage within ideology",
fill = "ideology"
) +
theme_minimal()
Stronger left-wing support for trans rights. Right-wing respondents are the most divided, with high opposition levels. Non-responses are highest among those without ideological alignment.
Social class
data_summary <- data |>
count(trans_docs, social_class, name = "n") |>
group_by(social_class) |>
mutate(percentage = n / sum(n))
ggplot(data_summary, aes(x = trans_docs, y = percentage, fill = social_class)) +
geom_bar(stat = "identity", position = "dodge") +
geom_text(aes(label = scales::percent(percentage, accuracy = 1)),
position = position_dodge(width = 0.9), vjust = -0.2, size = 4) +
scale_y_continuous(labels = percent_format()) +
labs(
title = "Distribution of support by social class",
x = "Support for trans people changing their civil documents",
y = "Percentage within social class",
fill = "social class"
) +
theme_minimal()
Although D63 of the questionnaire measures (oneself’s and one’s household’s) self-perceived social class, it is still a relevant and seemingly divisive variable. We observe a positive correlation, where support grows with increasing (perceived) social class, while explicit lack of support and no response are higher for lower-class individuals.
Education
ggplot(data, aes(x = trans_docs, y = years_edu)) +
geom_violin() +
labs(x = "Support for trans people changing their civil documents", y = "Age when stopped full-time education") +
ggtitle("Distribution of support by education")
Support doesn’t seem to be related to education.
Area of residence
data_summary <- data |>
count(trans_docs, community, name = "n") |>
group_by(community) |>
mutate(percentage = n / sum(n))
ggplot(data_summary, aes(x = trans_docs, y = percentage, fill = community)) +
geom_bar(stat = "identity", position = "dodge") +
geom_text(aes(label = scales::percent(percentage, accuracy = 1)),
position = position_dodge(width = 0.9), vjust = -0.2, size = 4) +
scale_y_continuous(labels = percent_format()) +
labs(
title = "Distribution of support by area of residence",
x = "Support for trans people changing their civil documents",
y = "Percentage within area of residence",
fill = "area of residence"
) +
theme_minimal()
Support does not vary much by area of residence.
Other individual-level variables
Having trans friends
data_summary <- data |>
count(trans_docs, friends_trans, name = "n") |>
group_by(friends_trans) |>
mutate(percentage = n / sum(n))
ggplot(data_summary, aes(x = trans_docs, y = percentage, fill = friends_trans)) +
geom_bar(stat = "identity", position = "dodge") +
geom_text(aes(label = scales::percent(percentage, accuracy = 1)),
position = position_dodge(width = 0.9), vjust = -0.2, size = 4) +
scale_y_continuous(labels = percent_format()) +
labs(
title = "Distribution of support by haivng trans friends",
x = "Support for trans people changing their civil documents",
y = "Percentage within groups",
fill = "Has Trans Friends"
) +
theme_minimal()
Having trans friends is associated with a higher support, while those who refuse to disclose their connections to trans people tend to oppose more.
Country-level EDA
Replication of the plot in Marga’s document. This is probably not needed in the final version of the document.
country_support <- data %>%
mutate(
trans_docs = case_when(
is.na(trans_docs) ~ "DK",
trans_docs == "Yes" ~ "1",
trans_docs == "No" ~ "2",
TRUE ~ as.character(trans_docs)
)
) %>%
group_by(country, trans_docs = trans_docs) %>%
summarise(count = n(), .groups = "drop") %>%
group_by(country) %>%
mutate(proportion = (count / sum(count))*100) %>%
ungroup()
ggplot(country_support, aes(x = factor(country, levels = country_support %>%
filter(trans_docs == "1") %>%
arrange(desc(proportion)) %>%
pull(country)),
y = proportion,
fill = factor(trans_docs, levels = c("1", "2", "DK")))) +
geom_bar(stat = "identity", position = position_stack(reverse = TRUE)) +
scale_fill_manual(values = c("1" = "#497ba9", "2" = "#d56e6e", "DK" = "#9a9595"),
name = "",
labels = c("Yes", "No", "Don't know")) +
geom_text(aes(label = round(proportion)),
position = position_stack(reverse = TRUE, vjust = 0.5),
size = 3.5, color = "white") +
labs(
title = "QC9: Do you think transgender persons should be able to change their civil documents to match their inner gender identity?",
x = "",
y = ""
) +
theme_minimal() +
theme(axis.text.x = element_text(angle = 45, hjust = 1),
axis.text.y = element_blank(),
axis.ticks.y = element_blank(),
plot.title = element_text(size = 9),
panel.grid.major.y = element_blank(),
legend.position = "bottom")
There are some mismatches, I guess the data might have become distorted at some point during processing, but I don’t know when.
trans_docs_prop <- country_support %>%
filter(trans_docs == "1") %>%
select(country, proportion) %>%
rename(trans_support = proportion)
country_long <- country_level_data %>%
inner_join(trans_docs_prop, by = c("iso2c" = "country")) |>
pivot_longer(cols = c(gdp_pc_ppp, gender_inequality_index, lgbt_policy_index, democracy_index),
names_to = "variable", values_to = "value")
ggplot(country_long, aes(x = value, y = trans_support)) +
geom_smooth(method = "lm", se = FALSE, color = "lightgray") + # we can remove this
geom_point(size = 2, color = "blue", alpha = 0.7) +
geom_text(aes(label = iso3c), vjust = -0.5, hjust = 0.5, size = 3) +
facet_wrap(~variable, scales = "free_x") +
labs(
title = "Relationship between country-level variables and trans support",
x = "Country-level variable",
y = "Proportion of Yes answers"
) +
theme_minimal()
Democracy and LGBT Policy indeces seem to have a positive linear relationship with the target variable, while Gender Inequality index has a negative linear relationship. The relationship with GDP per capita is non-linear (logarithmic?). There appears to be a “ceiling” of support, beyond which increases in GDP per capita lose effect.
Boxplots for country-level variables:
ggplot(country_long, aes(y = value, x = variable)) +
geom_boxplot(outlier.color = "red", outlier.shape = 16, fill = "lightblue") +
coord_flip() +
theme_minimal() +
labs(title = "Distribution of country-level variables", x = NULL, y = "value") +
facet_wrap(~variable, scales = "free") +
theme(axis.text.y = element_blank(),
axis.ticks.x = element_blank())
country_level_data_cor <- country_level_data %>%
inner_join(trans_docs_prop, by = c("iso2c" = "country"))
cor_matrix <- cor(country_level_data_cor %>%
select(gdp_pc_ppp, democracy_index, gender_inequality_index,
lgbt_policy_index, trans_support),
use = "complete.obs")
corrplot(cor_matrix, method = "color", type = "upper",
addCoef.col = "black", tl.col = "black",
col = colorRampPalette(c("blue", "white", "red"))(200))
Some heavy correlations which is a little worrying, but as we are going to use these data to build cross-level interactions, this should not compromise the reliability of our analysis too much.
Paradata
# Extracting labels in paradata
list_label_tibbles_paradata <- lapply(names(paradata), function(col_name) {
labels <- attr(paradata[[col_name]], "labels")
name_labels <- names(labels)
if (!is.null(labels)) {
tibble(name_labels = name_labels, labels = labels)
} else {
NULL
}
})
# Asign names to list elements
list_label_tibbles_paradata <- setNames(list_label_tibbles_paradata, names(paradata))
# Convert into factor
paradata <- paradata %>%
mutate(across(where(~ !is.null(attr(., "labels"))), labelled::to_factor))
# Merging datasets for the analysis
merged_paradata <- merge(data, paradata, by = "serialid", all.x = TRUE)Number of persons present during interview:
library(gmodels)
# Convert NA in a explicit category
merged_paradata$trans_docs <- as.character(merged_paradata$trans_docs)
merged_paradata$trans_docs[is.na(merged_paradata$trans_docs)] <- "DK"
merged_paradata$trans_docs <- as.factor(merged_paradata$trans_docs)
# CrossTable
CrossTable(merged_paradata$p4, merged_paradata$trans_docs,
digits=2,
expected=F,
asresid=T,
chisq=TRUE,
prop.chisq=F,
format="SPSS")
Cell Contents
|-------------------------|
| Count |
| Row Percent |
| Column Percent |
| Total Percent |
| Adj Std Resid |
|-------------------------|
Total Observations in Table: 27438
| merged_paradata$trans_docs
merged_paradata$p4 | DK | No | Yes | Row Total |
---------------------------------|-----------|-----------|-----------|-----------|
Two (interviewer and respondent) | 2806 | 8146 | 12428 | 23380 |
| 12.00% | 34.84% | 53.16% | 85.21% |
| 85.55% | 84.02% | 85.93% | |
| 10.23% | 29.69% | 45.29% | |
| 0.58 | -4.10 | 3.54 | |
---------------------------------|-----------|-----------|-----------|-----------|
Three | 428 | 1316 | 1758 | 3502 |
| 12.22% | 37.58% | 50.20% | 12.76% |
| 13.05% | 13.57% | 12.16% | |
| 1.56% | 4.80% | 6.41% | |
| 0.52 | 2.97 | -3.19 | |
---------------------------------|-----------|-----------|-----------|-----------|
Four | 36 | 189 | 218 | 443 |
| 8.13% | 42.66% | 49.21% | 1.61% |
| 1.10% | 1.95% | 1.51% | |
| 0.13% | 0.69% | 0.79% | |
| -2.50 | 3.25 | -1.49 | |
---------------------------------|-----------|-----------|-----------|-----------|
Five or more | 10 | 44 | 59 | 113 |
| 8.85% | 38.94% | 52.21% | 0.41% |
| 0.30% | 0.45% | 0.41% | |
| 0.04% | 0.16% | 0.22% | |
| -1.02 | 0.80 | -0.11 | |
---------------------------------|-----------|-----------|-----------|-----------|
Column Total | 3280 | 9695 | 14463 | 27438 |
| 11.95% | 35.33% | 52.71% | |
---------------------------------|-----------|-----------|-----------|-----------|
Statistics for All Table Factors
Pearson's Chi-squared test
------------------------------------------------------------
Chi^2 = 26.44717 d.f. = 6 p = 0.0001837381
Minimum expected frequency: 13.50827 The table shows a significant association between the number of people present during the interview and support for transgender people to change their documents
Regarding the duration of the interview we have 2 options p3 and p3r. We will use p3r to have a simpler analysis
# CrossTable
CrossTable(merged_paradata$p3r, merged_paradata$trans_docs,
digits=2,
expected=F,
asresid=T,
chisq=TRUE,
prop.chisq=F,
format="SPSS")
Cell Contents
|-------------------------|
| Count |
| Row Percent |
| Column Percent |
| Total Percent |
| Adj Std Resid |
|-------------------------|
Total Observations in Table: 27438
| merged_paradata$trans_docs
merged_paradata$p3r | DK | No | Yes | Row Total |
--------------------|-----------|-----------|-----------|-----------|
Up to 14 minutes | 73 | 224 | 260 | 557 |
| 13.11% | 40.22% | 46.68% | 2.03% |
| 2.23% | 2.31% | 1.80% | |
| 0.27% | 0.82% | 0.95% | |
| 0.85 | 2.43 | -2.88 | |
--------------------|-----------|-----------|-----------|-----------|
15 - 29 minutes | 782 | 2284 | 3456 | 6522 |
| 11.99% | 35.02% | 52.99% | 23.77% |
| 23.84% | 23.56% | 23.90% | |
| 2.85% | 8.32% | 12.60% | |
| 0.10 | -0.61 | 0.52 | |
--------------------|-----------|-----------|-----------|-----------|
30 - 44 minutes | 1429 | 4388 | 6305 | 12122 |
| 11.79% | 36.20% | 52.01% | 44.18% |
| 43.57% | 45.26% | 43.59% | |
| 5.21% | 15.99% | 22.98% | |
| -0.75 | 2.66 | -2.06 | |
--------------------|-----------|-----------|-----------|-----------|
45 - 59 minutes | 703 | 1993 | 3039 | 5735 |
| 12.26% | 34.75% | 52.99% | 20.90% |
| 21.43% | 20.56% | 21.01% | |
| 2.56% | 7.26% | 11.08% | |
| 0.80 | -1.04 | 0.48 | |
--------------------|-----------|-----------|-----------|-----------|
60 - 74 minutes | 202 | 529 | 908 | 1639 |
| 12.32% | 32.28% | 55.40% | 5.97% |
| 6.16% | 5.46% | 6.28% | |
| 0.74% | 1.93% | 3.31% | |
| 0.48 | -2.67 | 2.25 | |
--------------------|-----------|-----------|-----------|-----------|
75 - 89 minutes | 49 | 123 | 276 | 448 |
| 10.94% | 27.46% | 61.61% | 1.63% |
| 1.49% | 1.27% | 1.91% | |
| 0.18% | 0.45% | 1.01% | |
| -0.67 | -3.52 | 3.80 | |
--------------------|-----------|-----------|-----------|-----------|
90 minutes and more | 42 | 154 | 219 | 415 |
| 10.12% | 37.11% | 52.77% | 1.51% |
| 1.28% | 1.59% | 1.51% | |
| 0.15% | 0.56% | 0.80% | |
| -1.16 | 0.76 | 0.02 | |
--------------------|-----------|-----------|-----------|-----------|
Column Total | 3280 | 9695 | 14463 | 27438 |
| 11.95% | 35.33% | 52.71% | |
--------------------|-----------|-----------|-----------|-----------|
Statistics for All Table Factors
Pearson's Chi-squared test
------------------------------------------------------------
Chi^2 = 36.84302 d.f. = 12 p = 0.0002368813
Minimum expected frequency: 49.61003 Respondent cooperation
data_summary <- merged_paradata |>
count(p5, trans_docs, name = "n") |>
group_by(p5) |>
mutate(percentage = n / sum(n))
ggplot(data_summary, aes(x = p5, y = percentage, fill = trans_docs)) +
geom_bar(stat = "identity", position = "dodge") +
geom_text(aes(label = scales::percent(percentage, accuracy = 1)),
position = position_dodge(width = 0.9), vjust = -0.2, size = 4) +
scale_y_continuous(labels = percent_format()) +
labs(
title = "Distribution of support by Respondent cooperation",
x = "Respondent cooperation",
y = "Percentage within groups",
fill = "Support"
) +
theme_minimal()
Respondents who engaged better in the survey were more likely to express support.
Correlation and multicollinearity
Now we want to take a look at the possible multicollinearity of our explanatory variables. For it, we calculate the correlation of our numerical variables. As we have too many variables, we visualize just those with a strong correlation to focus on key dependencies.
cor_matrix <- cor(data %>%
select_if(is.numeric) %>%
select(-serialid),
use = "complete.obs")
corrplot(cor_matrix, method = "color", type = "upper",
tl.col = "black",
col = colorRampPalette(c("blue", "white", "red"))(200))
# Create a matrix where only correlations >= 0.7 are maintained
cor_filtered <- ifelse(abs(cor_matrix) >= 0.7, cor_matrix, NA)
# Graph
corrplot(cor_filtered, method = "color", type = "upper",
tl.col = "black",
col = colorRampPalette(c("blue", "white", "red"))(200),
na.label = " ",
insig = "blank") 
Most strong correlations are among variables related to race, religion or sexual orientation discrimination. Consequently, we are grouping them into 3 new composite variables by averaging related ones, in order to reduce multicollinearity.
# Creating grouped variables
data <- data %>%
mutate(
racial_discri = rowMeans(select(., roma_discri, black_discri, asian_discri), na.rm = TRUE), #no white
sexual_discri = rowMeans(select(., lgb_discri, trans_discri, intersex_discri), na.rm = TRUE),
religious_discri = rowMeans(select(., jewish_discri, muslim_discri, buddihst_discri), na.rm = TRUE)
)
# Removing original variables to avoid redundancy
data <- data |>
select(-c(roma_discri, black_discri, asian_discri, lgb_discri, trans_discri, intersex_discri, jewish_discri, muslim_discri, buddihst_discri))
# Graphical representation
cor_matrix <- cor(data %>%
select_if(is.numeric) %>%
select(-serialid),
use = "complete.obs")
corrplot(cor_matrix, method = "color", type = "upper",
tl.col = "black",
col = colorRampPalette(c("blue", "white", "red"))(200))
We realize our new variables are still highly correlated between them. For reducing the dimensionality of the dataset even more while preserving information we create one single variable for general minority discrimination.
We decided to exclude white_discri, atheist_discri, christian_discri because we realized they had a median of 1 and a quite small mean, meaning there is almost no reported discrimination against these groups in the dataset.
summary(data$white_discri) Min. 1st Qu. Median Mean 3rd Qu. Max. NA's
1.000 1.000 1.000 1.785 2.000 10.000 403 summary(data$atheist_discri) Min. 1st Qu. Median Mean 3rd Qu. Max. NA's
1.000 1.000 1.500 2.802 4.000 10.000 517 summary(data$christian_discri) Min. 1st Qu. Median Mean 3rd Qu. Max. NA's
1.000 1.000 1.000 1.904 2.000 10.000 414 Final check of the correlation matrix to confirm that multicollinearity has been reduced.
cor_matrix <- cor(data %>%
select_if(is.numeric) %>%
select(-serialid),
use = "complete.obs")
corrplot(cor_matrix, method = "color", type = "upper",
addCoef.col = "black", tl.col = "black",
col = colorRampPalette(c("blue", "white", "red"))(200))
Class imbalance
prop.table(table(data$trans_docs, useNA = "ifany"))
Yes No <NA>
0.5271157 0.3533421 0.1195422 prop.table(table(data$trans_docs, useNA = "no"))
Yes No
0.5986837 0.4013163 Our target variable has a 60/40 distribution so we are not worried about class imbalance.
Less represented classes in other variables have already been aggregated if deemed necessary.
Analysis of missing values
Here we analyse the NA reponses to our target variable. This is a sort of robustness check to understand our data and learn if there are patterns in NA response that we should be worried about e.g. if there are specific demographics of people who are less likely to respond.
Overall the analysis below shows that non response is similar to the descriptive data and aligned with some groups reported “No” to supporting trans_docs in c19. So we’re more at risk of underreporting “no” votes in this survey due to non-response. The correlation is low though so it’s not a major concern.
Who is more likely to not respond to our target?
There are 3,280 NA responses to the target variable. To try understand if the missing values are at random, we will test the correlation between NA response and Use the DK (don’t know) for our target variable.
In the descriptive analysis above, we have already seen in raw terms that NA responses were more frequent from some groups e.g.
women,
older people,
people who also responded NA for political ideology,
People who do not have trans friends and those who refused to respond to the friendship question had higher NA responses to the target variable.
People with lower survey cooperation
By country, we already understand from the challenge description that the NA responses vary. This is a significant disparity.
Create a binary variable for the DK
cntry_name <- codelist |> select(iso2c, country_name = country.name.en)
dk_target <- data |>
mutate(target_NA = ifelse(is.na(trans_docs), 1, 0)) |>
left_join(cntry_name, by = join_by(country == iso2c)) |>
dplyr::select(-trans_docs, -serialid, -country)
table(dk_target$target_NA)
0 1
24158 3280 Confirm DK rates by country. They vary from 1.4% in Belgium to 28.5% in Bulgaria. Overall, the average is 11.95%.
dk_target |>
group_by(country_name) |>
summarise(count_na = sum(target_NA),
num_resp = length(country_name),
pct_na = count_na/num_resp*100) |>
ggplot(aes(x=reorder(country_name, -pct_na), y = pct_na))+
geom_col()+
theme(axis.text.x = element_text(angle = 45, hjust = 1),
axis.title.x = element_blank()) +
scale_y_continuous(labels = scales::percent_format(scale = 1)) +
labs(y = "Proportion of NA responses")
If all NA responses to the target are removed, this is how much the “Yes” count increases for each of our countries. We see this is not proportional. This is a statistical phenomenon. distribution of the variable looks by country. The NA vote removal, makes our differences in Yes/No differences appear larger.
data |>
group_by(country) |>
summarise(yes_count = sum(trans_docs == "Yes", na.rm=TRUE),
num_resp = sum(!is.na(trans_docs)),
num_na = sum(is.na(trans_docs)),
pct_yes_withna = yes_count / length(country)*100,
pct_yes = yes_count/num_resp*100)|>
ggplot(aes(x = reorder(country, -pct_yes))) +
geom_col(aes(y = pct_yes), fill = "red") + # First bar (pct_yes)
geom_col(aes(y = pct_yes_withna), fill = "yellow", alpha = 0.5) + # Second bar (pct_yes_withna)
theme(axis.text.x = element_text(angle = 45, hjust = 1),
axis.title.x = element_blank()) +
scale_y_continuous(labels = scales::percent_format(scale = 1),
limits = c(0,100)) +
labs(title ="Support for transgender rights to legally change documents, with and without NA's")
Check correlation with DK of target
Run model to test what is correlated with DK response, use Cramers V for association between the factor variables and correlation for the numeric variables in the cleaned data.
- Model the data for DK responses against the factor variables.
factor_subset <- dk_target %>%
dplyr::select(target_NA, where(is.factor)) |>
mutate(target_NA = factor(target_NA))
# Run cramers V for factors
target_var <- "target_NA"
factor_variables <- names(factor_subset)
factor_variables <- factor_variables[factor_variables != target_var]
cramers_v_results <- list()
for (variable in factor_variables) {
contingency_table <- table(factor_subset[[target_var]],
factor_subset[[variable]])
cramers_v <- CramerV(contingency_table)
cramers_v_results[[variable]] <- cramers_v
}
# Create a Tibble for Results
cat_results <- tibble(variable = names(cramers_v_results),
cramers_v = unlist(cramers_v_results)) |>
arrange(desc(cramers_v))
cat_results# A tibble: 22 × 2
variable cramers_v
<chr> <dbl>
1 internet_use 0.136
2 social_class 0.0975
3 occupation 0.0852
4 marital_status 0.0831
5 gender_docs 0.0820
6 religion 0.0763
7 phone_access 0.0711
8 life_sat 0.0642
9 polintr 0.0621
10 friends_trans 0.0581
# ℹ 12 more rowsThis shows all of the factors have quite low association with the NA responses. The highest being internet use. This is a good sign that the missing values are random.
- Look at the numeric variables and test correlations:
numeric_subset <- dk_target %>%
dplyr::select(target_NA, where(is.numeric))
target_var <- "target_NA"
numeric_variables <- names(numeric_subset)[names(numeric_subset) != target_var]
cor_results <- list()
for (variable in numeric_variables) {
correlation <- cor(numeric_subset$target_NA,
numeric_subset[[variable]],
use = "pairwise.complete.obs")
cor_results[[variable]] <- correlation
}
# Create a Tibble for Results
cor_results <- tibble(variable = names(cor_results),
cor = unlist(cor_results)) |>
arrange(cor)
cor_results# A tibble: 7 × 2
variable cor
<chr> <dbl>
1 n_actions_against_discri -0.0988
2 n_friends_minorities -0.0965
3 years_edu -0.0544
4 social_alienation 0.0566
5 minority_discri 0.0635
6 age 0.0982
7 antilgbtq_rights 0.108 Again, this is not too much cause for concern. We only have around 10% correlations, positive and negative with the target variable.
Modelling relationship with key variables and non-response
Here we run a logistic regression to test for the most important/significant variables. First, we make a subset of data with only our variables that were most correlated in the seciton above (use above +/- 9.5% correlation and above 10% cramers V) and also include gender and country.
[1] "age" "antilgbtq_rights"[1] "internet_use"Now model with those variables to see if they are significant in explaining the DK values. Gender will also be included as a key variable.
We run a stepwise AIC on these most correlated variables and then use the best model to test the overall model fit.
# first, run stepwise to determine most important
# run base model
dk_fit_null <- glm(target_NA ~ 1,
data = dk_target,
family = "binomial")
# run full fit model of most correlated vars with country (also age^2 for good practice)
dk_fit <- glm(target_NA ~ gender + age + I(age*age) + antilgbtq_rights + internet_use + social_class + country_name,
data = dk_target,
family = "binomial")
# use stepwise to select best mode l
aic_1 <- MASS::stepAIC(dk_fit, scope = list(upper = dk_fit,
lower = dk_fit_null),
direction = "both", k = 2, trace=0) # forward based on AIC
# filter vars significant at 5% and calculate exponential
broom::tidy(aic_1) |>
filter(p.value<0.05) |>
mutate(oddsratio = exp(estimate)) |>
select(term, oddsratio, p.value)# A tibble: 29 × 3
term oddsratio p.value
<chr> <dbl> <dbl>
1 (Intercept) 0.0500 8.78e-40
2 genderWoman 1.20 2.01e- 5
3 I(age * age) 1.00 4.77e- 4
4 antilgbtq_rights 1.13 9.69e- 7
5 internet_useTwo or three times a week 1.21 2.72e- 2
6 internet_useTwo or three times a month 0.307 4.97e- 3
7 internet_useNever/No access 1.28 2.49e- 4
8 internet_useNo Internet access at all 1.57 4.62e- 4
9 social_classThe lower middle class of society 0.766 4.62e- 5
10 social_classThe middle class of society 0.713 4.09e-11
# ℹ 19 more rowsThe best model is the one without age but includes age^2. So we run the full model to keep the lower level variables included.
The model has some interesting findings to who did not respond to our findings. Some things we can see with the odds ratios (excluding interpretation of countries as that is covered above):
women are around 20% more likely to give NA responses
Anti-lgbti rights people were about 10% more likely to not respond
Internet use was significant but is not interpertable. If you had not used the internet (higher NA likelihood) or used it 2-3 times a week (lower NA likelihood) compared to everyday use
Social class was significant at all levels, compared to the working class, you were more likely to not respond to our target variable if you reported being in the lower middle, middle or upper middle class. I.e. working class were less likely to answer this question.
Below is an option using undersampling which is probably more legit too.
# split to test and training
na_model <- glm(target_NA ~ .,
data = dk_target,
family = "binomial")
summary(na_model)
Call:
glm(formula = target_NA ~ ., family = "binomial", data = dk_target)
Coefficients:
Estimate
(Intercept) -5.096435
age 0.012178
genderWoman 0.164789
years_edu -0.005912
communitySmall or middle sized town 0.060070
communityLarge town -0.083705
marital_statusSingle living with partner (5-8 in d7) -0.229059
marital_statusSingle (9-10 in d7) -0.151896
marital_statusDivorced or separated (11-12 in d7) 0.289686
marital_statusWidow (13-14 in d7) 0.216811
occupationManagers (10 to 12 in d15a) 0.074469
occupationOther white collars (13 or 14 in d15a) -0.002162
occupationManual workers (15 to 18 in d15a) -0.087856
occupationHouse persons (1 in d15a) -0.244480
occupationUnemployed (3 in d15a) 0.032945
occupationRetired (4 in d15a) -0.152771
occupationStudents (2 in d15a) -0.516985
social_classThe lower middle class of society -0.191067
social_classThe middle class of society -0.102517
social_classThe upper middle class of society -0.048871
social_classThe higher class of society 0.028047
religionOrthodox Christian -0.272443
religionProtestant 0.161109
religionOther Christian -0.132124
religionOther -0.791153
religionMuslim 0.691685
religionNon-believers -0.020914
nonEU_national1 -0.370848
phone_accessLandline only -0.110733
phone_accessLandline & mobile 0.039715
phone_accessNo telephone -0.500657
bill_issuesFrom time to time 0.232590
bill_issuesAlmost never/never 0.457448
internet_useTwo or three times a week 0.184435
internet_useAbout once a week 0.437365
internet_useTwo or three times a month -1.580741
internet_useLess often 0.079182
internet_useNever/No access 0.290840
internet_useNo Internet access at all 0.312489
life_satFairly satisfied 0.053242
life_satNot very satisfied 0.291434
life_satNot at all satisfied 0.005602
polintrMedium 0.080670
polintrLow 0.126350
polintrNot at all -0.045332
left_right(5 - 6) Centre 0.122380
left_right(7 -10) Right 0.094612
social_alienation 0.124139
ethnic_minority1 0.461184
skincolor_minority1 -0.927202
religious_minority1 -0.483626
roma_minority1 -0.234027
sexual_minority1 -0.429264
disability_minority1 0.278993
suffered_discr1 -0.380922
gender_docsNo 0.536267
friends_transNo -0.075223
friends_transRefusal (SPONTANEOUS) 0.147667
n_friends_minorities 0.037060
n_actions_against_discri -0.150414
antilgbtq_rights 0.055886
minority_discri -0.028983
country_nameBelgium -1.057217
country_nameBulgaria 1.258296
country_nameCroatia -0.006931
country_nameCyprus 0.618536
country_nameCzechia 0.063576
country_nameDenmark 0.020749
country_nameEstonia 0.498044
country_nameFinland 0.506632
country_nameFrance 0.209453
country_nameGermany 0.551572
country_nameGreece 0.155828
country_nameHungary -0.199701
country_nameIreland 0.042946
country_nameItaly 0.258879
country_nameLatvia 0.686826
country_nameLithuania 0.118117
country_nameLuxembourg -0.023112
country_nameMalta -0.619311
country_nameNetherlands -0.325966
country_namePoland 0.501405
country_namePortugal -0.339504
country_nameRomania -0.023516
country_nameSlovakia 0.249307
country_nameSlovenia 0.151497
country_nameSpain -0.389991
country_nameSweden 0.821909
country_nameUnited Kingdom 0.544943
Std. Error
(Intercept) 0.505490
age 0.004217
genderWoman 0.082464
years_edu 0.007160
communitySmall or middle sized town 0.095266
communityLarge town 0.106848
marital_statusSingle living with partner (5-8 in d7) 0.153178
marital_statusSingle (9-10 in d7) 0.148656
marital_statusDivorced or separated (11-12 in d7) 0.129040
marital_statusWidow (13-14 in d7) 0.125780
occupationManagers (10 to 12 in d15a) 0.188675
occupationOther white collars (13 or 14 in d15a) 0.186434
occupationManual workers (15 to 18 in d15a) 0.174101
occupationHouse persons (1 in d15a) 0.263347
occupationUnemployed (3 in d15a) 0.250771
occupationRetired (4 in d15a) 0.176731
occupationStudents (2 in d15a) 0.364050
social_classThe lower middle class of society 0.127529
social_classThe middle class of society 0.102911
social_classThe upper middle class of society 0.182548
social_classThe higher class of society 0.527417
religionOrthodox Christian 0.208576
religionProtestant 0.154425
religionOther Christian 0.206172
religionOther 0.279671
religionMuslim 0.325376
religionNon-believers 0.130285
nonEU_national1 1.018180
phone_accessLandline only 0.229728
phone_accessLandline & mobile 0.100780
phone_accessNo telephone 0.355297
bill_issuesFrom time to time 0.188589
bill_issuesAlmost never/never 0.188085
internet_useTwo or three times a week 0.156891
internet_useAbout once a week 0.257105
internet_useTwo or three times a month 1.011667
internet_useLess often 0.337876
internet_useNever/No access 0.128823
internet_useNo Internet access at all 0.268088
life_satFairly satisfied 0.101376
life_satNot very satisfied 0.144484
life_satNot at all satisfied 0.247800
polintrMedium 0.107402
polintrLow 0.136224
polintrNot at all 0.151273
left_right(5 - 6) Centre 0.097494
left_right(7 -10) Right 0.105449
social_alienation 0.048298
ethnic_minority1 0.233612
skincolor_minority1 0.522311
religious_minority1 0.269626
roma_minority1 0.404566
sexual_minority1 0.520931
disability_minority1 0.250759
suffered_discr1 0.137183
gender_docsNo 0.092952
friends_transNo 0.151250
friends_transRefusal (SPONTANEOUS) 0.397164
n_friends_minorities 0.024872
n_actions_against_discri 0.064844
antilgbtq_rights 0.052789
minority_discri 0.022540
country_nameBelgium 0.426007
country_nameBulgaria 0.346358
country_nameCroatia 0.341891
country_nameCyprus 0.449668
country_nameCzechia 0.328735
country_nameDenmark 0.350265
country_nameEstonia 0.333545
country_nameFinland 0.328111
country_nameFrance 0.338444
country_nameGermany 0.302573
country_nameGreece 0.405321
country_nameHungary 0.337837
country_nameIreland 0.348477
country_nameItaly 0.342212
country_nameLatvia 0.320758
country_nameLithuania 0.329320
country_nameLuxembourg 0.449294
country_nameMalta 0.644793
country_nameNetherlands 0.367757
country_namePoland 0.326395
country_namePortugal 0.391052
country_nameRomania 0.400689
country_nameSlovakia 0.319901
country_nameSlovenia 0.338876
country_nameSpain 0.392042
country_nameSweden 0.320433
country_nameUnited Kingdom 0.329095
z value Pr(>|z|)
(Intercept) -10.082 < 2e-16
age 2.888 0.00388
genderWoman 1.998 0.04568
years_edu -0.826 0.40898
communitySmall or middle sized town 0.631 0.52833
communityLarge town -0.783 0.43339
marital_statusSingle living with partner (5-8 in d7) -1.495 0.13481
marital_statusSingle (9-10 in d7) -1.022 0.30688
marital_statusDivorced or separated (11-12 in d7) 2.245 0.02477
marital_statusWidow (13-14 in d7) 1.724 0.08476
occupationManagers (10 to 12 in d15a) 0.395 0.69307
occupationOther white collars (13 or 14 in d15a) -0.012 0.99075
occupationManual workers (15 to 18 in d15a) -0.505 0.61382
occupationHouse persons (1 in d15a) -0.928 0.35322
occupationUnemployed (3 in d15a) 0.131 0.89548
occupationRetired (4 in d15a) -0.864 0.38736
occupationStudents (2 in d15a) -1.420 0.15558
social_classThe lower middle class of society -1.498 0.13407
social_classThe middle class of society -0.996 0.31917
social_classThe upper middle class of society -0.268 0.78892
social_classThe higher class of society 0.053 0.95759
religionOrthodox Christian -1.306 0.19148
religionProtestant 1.043 0.29682
religionOther Christian -0.641 0.52162
religionOther -2.829 0.00467
religionMuslim 2.126 0.03352
religionNon-believers -0.161 0.87247
nonEU_national1 -0.364 0.71569
phone_accessLandline only -0.482 0.62979
phone_accessLandline & mobile 0.394 0.69353
phone_accessNo telephone -1.409 0.15880
bill_issuesFrom time to time 1.233 0.21746
bill_issuesAlmost never/never 2.432 0.01501
internet_useTwo or three times a week 1.176 0.23977
internet_useAbout once a week 1.701 0.08892
internet_useTwo or three times a month -1.563 0.11817
internet_useLess often 0.234 0.81471
internet_useNever/No access 2.258 0.02397
internet_useNo Internet access at all 1.166 0.24377
life_satFairly satisfied 0.525 0.59945
life_satNot very satisfied 2.017 0.04369
life_satNot at all satisfied 0.023 0.98196
polintrMedium 0.751 0.45259
polintrLow 0.928 0.35366
polintrNot at all -0.300 0.76443
left_right(5 - 6) Centre 1.255 0.20939
left_right(7 -10) Right 0.897 0.36960
social_alienation 2.570 0.01016
ethnic_minority1 1.974 0.04837
skincolor_minority1 -1.775 0.07587
religious_minority1 -1.794 0.07286
roma_minority1 -0.578 0.56295
sexual_minority1 -0.824 0.40992
disability_minority1 1.113 0.26588
suffered_discr1 -2.777 0.00549
gender_docsNo 5.769 7.96e-09
friends_transNo -0.497 0.61895
friends_transRefusal (SPONTANEOUS) 0.372 0.71004
n_friends_minorities 1.490 0.13622
n_actions_against_discri -2.320 0.02036
antilgbtq_rights 1.059 0.28975
minority_discri -1.286 0.19851
country_nameBelgium -2.482 0.01308
country_nameBulgaria 3.633 0.00028
country_nameCroatia -0.020 0.98383
country_nameCyprus 1.376 0.16896
country_nameCzechia 0.193 0.84665
country_nameDenmark 0.059 0.95276
country_nameEstonia 1.493 0.13539
country_nameFinland 1.544 0.12257
country_nameFrance 0.619 0.53600
country_nameGermany 1.823 0.06831
country_nameGreece 0.384 0.70064
country_nameHungary -0.591 0.55444
country_nameIreland 0.123 0.90192
country_nameItaly 0.756 0.44936
country_nameLatvia 2.141 0.03225
country_nameLithuania 0.359 0.71984
country_nameLuxembourg -0.051 0.95898
country_nameMalta -0.960 0.33681
country_nameNetherlands -0.886 0.37542
country_namePoland 1.536 0.12449
country_namePortugal -0.868 0.38530
country_nameRomania -0.059 0.95320
country_nameSlovakia 0.779 0.43579
country_nameSlovenia 0.447 0.65483
country_nameSpain -0.995 0.31985
country_nameSweden 2.565 0.01032
country_nameUnited Kingdom 1.656 0.09775
(Intercept) ***
age **
genderWoman *
years_edu
communitySmall or middle sized town
communityLarge town
marital_statusSingle living with partner (5-8 in d7)
marital_statusSingle (9-10 in d7)
marital_statusDivorced or separated (11-12 in d7) *
marital_statusWidow (13-14 in d7) .
occupationManagers (10 to 12 in d15a)
occupationOther white collars (13 or 14 in d15a)
occupationManual workers (15 to 18 in d15a)
occupationHouse persons (1 in d15a)
occupationUnemployed (3 in d15a)
occupationRetired (4 in d15a)
occupationStudents (2 in d15a)
social_classThe lower middle class of society
social_classThe middle class of society
social_classThe upper middle class of society
social_classThe higher class of society
religionOrthodox Christian
religionProtestant
religionOther Christian
religionOther **
religionMuslim *
religionNon-believers
nonEU_national1
phone_accessLandline only
phone_accessLandline & mobile
phone_accessNo telephone
bill_issuesFrom time to time
bill_issuesAlmost never/never *
internet_useTwo or three times a week
internet_useAbout once a week .
internet_useTwo or three times a month
internet_useLess often
internet_useNever/No access *
internet_useNo Internet access at all
life_satFairly satisfied
life_satNot very satisfied *
life_satNot at all satisfied
polintrMedium
polintrLow
polintrNot at all
left_right(5 - 6) Centre
left_right(7 -10) Right
social_alienation *
ethnic_minority1 *
skincolor_minority1 .
religious_minority1 .
roma_minority1
sexual_minority1
disability_minority1
suffered_discr1 **
gender_docsNo ***
friends_transNo
friends_transRefusal (SPONTANEOUS)
n_friends_minorities
n_actions_against_discri *
antilgbtq_rights
minority_discri
country_nameBelgium *
country_nameBulgaria ***
country_nameCroatia
country_nameCyprus
country_nameCzechia
country_nameDenmark
country_nameEstonia
country_nameFinland
country_nameFrance
country_nameGermany .
country_nameGreece
country_nameHungary
country_nameIreland
country_nameItaly
country_nameLatvia *
country_nameLithuania
country_nameLuxembourg
country_nameMalta
country_nameNetherlands
country_namePoland
country_namePortugal
country_nameRomania
country_nameSlovakia
country_nameSlovenia
country_nameSpain
country_nameSweden *
country_nameUnited Kingdom .
---
Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
(Dispersion parameter for binomial family taken to be 1)
Null deviance: 6149.9 on 18337 degrees of freedom
Residual deviance: 5702.8 on 18249 degrees of freedom
(9100 observations deleted due to missingness)
AIC: 5880.8
Number of Fisher Scoring iterations: 7broom::tidy(na_model)# A tibble: 89 × 5
term estimate std.error statistic p.value
<chr> <dbl> <dbl> <dbl> <dbl>
1 (Intercept) -5.10 0.505 -10.1 6.62e-24
2 age 0.0122 0.00422 2.89 3.88e- 3
3 genderWoman 0.165 0.0825 2.00 4.57e- 2
4 years_edu -0.00591 0.00716 -0.826 4.09e- 1
5 communitySmall or middle siz… 0.0601 0.0953 0.631 5.28e- 1
6 communityLarge town -0.0837 0.107 -0.783 4.33e- 1
7 marital_statusSingle living … -0.229 0.153 -1.50 1.35e- 1
8 marital_statusSingle (9-10 i… -0.152 0.149 -1.02 3.07e- 1
9 marital_statusDivorced or se… 0.290 0.129 2.24 2.48e- 2
10 marital_statusWidow (13-14 i… 0.217 0.126 1.72 8.48e- 2
# ℹ 79 more rowsexp(coefficients(na_model)) (Intercept)
0.006118521
age
1.012252085
genderWoman
1.179144394
years_edu
0.994105573
communitySmall or middle sized town
1.061910918
communityLarge town
0.919702513
marital_statusSingle living with partner (5-8 in d7)
0.795281376
marital_statusSingle (9-10 in d7)
0.859077470
marital_statusDivorced or separated (11-12 in d7)
1.336008000
marital_statusWidow (13-14 in d7)
1.242109894
occupationManagers (10 to 12 in d15a)
1.077311509
occupationOther white collars (13 or 14 in d15a)
0.997840105
occupationManual workers (15 to 18 in d15a)
0.915892418
occupationHouse persons (1 in d15a)
0.783111899
occupationUnemployed (3 in d15a)
1.033494121
occupationRetired (4 in d15a)
0.858326624
occupationStudents (2 in d15a)
0.596316021
social_classThe lower middle class of society
0.826076903
social_classThe middle class of society
0.902562665
social_classThe upper middle class of society
0.952304428
social_classThe higher class of society
1.028443714
religionOrthodox Christian
0.761516508
religionProtestant
1.174812676
religionOther Christian
0.876232166
religionOther
0.453321737
religionMuslim
1.997077577
religionNon-believers
0.979303553
nonEU_national1
0.690148654
phone_accessLandline only
0.895177305
phone_accessLandline & mobile
1.040514134
phone_accessNo telephone
0.606132435
bill_issuesFrom time to time
1.261863952
bill_issuesAlmost never/never
1.580036385
internet_useTwo or three times a week
1.202538557
internet_useAbout once a week
1.548620752
internet_useTwo or three times a month
0.205822438
internet_useLess often
1.082401205
internet_useNever/No access
1.337550906
internet_useNo Internet access at all
1.366822298
life_satFairly satisfied
1.054685123
life_satNot very satisfied
1.338345661
life_satNot at all satisfied
1.005618084
polintrMedium
1.084013516
polintrLow
1.134678895
polintrNot at all
0.955679809
left_right(5 - 6) Centre
1.130183275
left_right(7 -10) Right
1.099231740
social_alienation
1.132173128
ethnic_minority1
1.585950517
skincolor_minority1
0.395659376
religious_minority1
0.616543469
roma_minority1
0.791340592
sexual_minority1
0.650987925
disability_minority1
1.321797816
suffered_discr1
0.683231382
gender_docsNo
1.709613372
friends_transNo
0.927536237
friends_transRefusal (SPONTANEOUS)
1.159127418
n_friends_minorities
1.037755175
n_actions_against_discri
0.860352034
antilgbtq_rights
1.057477224
minority_discri
0.971433339
country_nameBelgium
0.347421173
country_nameBulgaria
3.519418325
country_nameCroatia
0.993092912
country_nameCyprus
1.856208043
country_nameCzechia
1.065640125
country_nameDenmark
1.020965585
country_nameEstonia
1.645499121
country_nameFinland
1.659691425
country_nameFrance
1.233003664
country_nameGermany
1.735979599
country_nameGreece
1.168625297
country_nameHungary
0.818975930
country_nameIreland
1.043881063
country_nameItaly
1.295477566
country_nameLatvia
1.987397162
country_nameLithuania
1.125375345
country_nameLuxembourg
0.977153472
country_nameMalta
0.538315374
country_nameNetherlands
0.721830044
country_namePoland
1.651040115
country_namePortugal
0.712123337
country_nameRomania
0.976758747
country_nameSlovakia
1.283136036
country_nameSlovenia
1.163574636
country_nameSpain
0.677063226
country_nameSweden
2.274838960
country_nameUnited Kingdom
1.724509350 Approach to test relationship to DK with splitting and undersampling:
# create new dataset with just vars we want, including age^2
dk_target2 <- dk_target |>
select(target_NA, age, antilgbtq_rights, internet_use, social_class, country_name) |>
mutate(age_sq = age*age, .after = age)
# to deal with some class imbalance, undersample from the majority group (NA = 0)
set.seed(123)
# Generate an index
index <- createDataPartition(dk_target2$target_NA, p = 0.7, list = FALSE, times = 1)
# Subset the dataframe
train <- dk_target2[index, ]
test <- dk_target2[-index, ]
# check splits
prop.table(table(train$target_NA))
0 1
0.8787421 0.1212579 prop.table(table(test$target_NA))
0 1
0.8844612 0.1155388 Now undersample the majority
set.seed(123)
under <- ovun.sample(target_NA~.,
data=train,
method = "under",
N = 4000)$data
# limit the sample to 4000 obs as we have ~2300 for target minority class.
table(under$target_NA)
0 1
2112 1888 #run the rf model
rfunder <- randomForest(target_NA~., data=under)
rfunder
Call:
randomForest(formula = target_NA ~ ., data = under)
Type of random forest: regression
Number of trees: 500
No. of variables tried at each split: 2
Mean of squared residuals: 0.2389922
% Var explained: 4.1We see that only around 5% of the variance is explained.
Testing the NA values against paradata
Here we extend the model to see if paradata is related to changed non-response.
para <- paradata |>
bind_cols(trans_docs = data$trans_docs,
age = data$age,
gender = data$gender,
country = data$country) |>
mutate(target_NA = ifelse(is.na(trans_docs), 1, 0)) |>
select(-serialid, -trans_docs)
summary(para$target_NA) Min. 1st Qu. Median Mean 3rd Qu. Max.
0.0000 0.0000 0.0000 0.1195 0.0000 1.0000 str(para)tibble [27,438 × 9] (S3: tbl_df/tbl/data.frame)
$ p2 : Factor w/ 6 levels "Before 8 h","8 - 12 h",..: 4 4 3 4 2 4 5 2 4 4 ...
..- attr(*, "label")= chr "TIME OF INTERVIEW"
$ p3 : Factor w/ 246 levels "2 minutes","3",..: 44 39 37 30 30 25 26 33 39 39 ...
..- attr(*, "label")= chr "DURATION OF INTERVIEW"
$ p3r : Factor w/ 7 levels "Up to 14 minutes",..: 4 3 3 3 3 2 2 3 3 3 ...
..- attr(*, "label")= chr "DURATION OF INTERVIEW (RECODED)"
$ p4 : Factor w/ 5 levels "Two (interviewer and respondent)",..: 1 1 1 1 1 1 1 1 1 1 ...
..- attr(*, "label")= chr "N OF PERSONS PRESENT DURING INTERVIEW"
$ p5 : Factor w/ 5 levels "Excellent","Fair",..: 1 1 1 1 1 1 1 1 1 1 ...
..- attr(*, "label")= chr "RESPONDENT COOPERATION"
$ age : num [1:27438] 51 62 38 29 63 41 48 88 44 45 ...
$ gender : Factor w/ 2 levels "Man","Woman": 1 2 2 1 2 2 1 1 2 2 ...
$ country : chr [1:27438] "BE" "BE" "BE" "BE" ...
$ target_NA: num [1:27438] 0 0 0 0 0 0 0 0 0 0 ...First, again test correlation. We use Cramers V since we only have factors:
target_var <- "target_NA"
para_vars <- names(para)[names(para) != target_var]
cramers_v_results <- list()
for (variable in para_vars) {
contingency_table <- table(para[[target_var]],
para[[variable]])
contingency_table_no_dk <- contingency_table[, colnames(contingency_table) != "DK"]
cramers_v <- CramerV(contingency_table_no_dk)
# include this for no DK as it is all zero which creates errors
cramers_v_results[[variable]] <- cramers_v
}
# Create a Tibble for Results
tibble(variable = names(cramers_v_results),
cramers_v = unlist(cramers_v_results)) |>
arrange(desc(cramers_v))# A tibble: 8 × 2
variable cramers_v
<chr> <dbl>
1 country 0.168
2 age 0.123
3 p5 0.106
4 p3 0.0916
5 gender 0.0292
6 p4 0.0165
7 p2 0.0116
8 p3r 0.0113Again, we see low correlation with the paradata and cramers V.
Second, we run another logistic model with just Paradata included.
na_para_model <- glm(target_NA ~ p2 + p3r + p4 + p5 + age + I(age*age) + gender + factor(country),
data = para,
family=binomial(link = "logit"))
broom::tidy(na_para_model) |>
filter(p.value<0.05) |>
mutate(oddsratio = exp(estimate)) |>
select(term, oddsratio, p.value)# A tibble: 25 × 3
term oddsratio p.value
<chr> <dbl> <dbl>
1 (Intercept) 0.0439 4.65e-12
2 p4Four 0.694 4.20e- 2
3 p5Fair 1.42 2.05e-15
4 p5Average 1.74 8.91e-18
5 p5Bad 3.49 2.14e-22
6 age 0.983 2.85e- 3
7 I(age * age) 1.00 3.43e- 9
8 genderWoman 1.14 1.07e- 3
9 factor(country)BE 0.179 6.77e- 9
10 factor(country)BG 5.30 2.16e-31
# ℹ 15 more rowsWe see that when controlling for age, gender and country, the survey cooperation variable is significant.
When compared to those with an excellent cooperation rating, people were more likely to respond. This increases with lacking cooperation. If cooperation was fair, there was around 40% more chance of NA, if cooperation was average, around 75% higher chance of NA. If cooperation was bad, there was about 350% higher chance of a NA response to our target variable.
Overall, the correlations with our target variables are low which means we don’t have a major concern. Some are interesting e.g. interview cooperation. The worse the cooperation, the more likely to not respond to the question. This could be underreporting No votes, because as we saw in the descriptive analysis, the worse the cooperation, the higher the No vote for supporting trans_docs. There could also be some reverse causality, as not responding leads to a worse cooperation score. But the odds ratios here are very high.
Imputing missing data
As we have different types of variables we decide to go with the default methods. Selecting the best method for each type of variable would be too computationally intensive
# Excluding target variable and other useless variables
imputation_data <- data |>
select(-c(serialid, country, trans_docs))
# Running it with the default methods
imputed_data <- mice(imputation_data, m = 1, seed=1234)
iter imp variable
1 1 years_edu community marital_status social_class religion bill_issues life_sat left_right social_alienation gender_docs friends_trans antilgbtq_rights minority_discri
2 1 years_edu community marital_status social_class religion bill_issues life_sat left_right social_alienation gender_docs friends_trans antilgbtq_rights minority_discri
3 1 years_edu community marital_status social_class religion bill_issues life_sat left_right social_alienation gender_docs friends_trans antilgbtq_rights minority_discri
4 1 years_edu community marital_status social_class religion bill_issues life_sat left_right social_alienation gender_docs friends_trans antilgbtq_rights minority_discri
5 1 years_edu community marital_status social_class religion bill_issues life_sat left_right social_alienation gender_docs friends_trans antilgbtq_rights minority_discri# By default: numerical variables -> pmm, binary factors -> logreg, > 2 levels factors -> polyreg
imputed_data$method age gender
"" ""
years_edu community
"pmm" "polyreg"
marital_status occupation
"polyreg" ""
social_class religion
"polyreg" "polyreg"
nonEU_national phone_access
"" ""
bill_issues internet_use
"polyreg" ""
life_sat polintr
"polyreg" ""
left_right social_alienation
"polyreg" "pmm"
ethnic_minority skincolor_minority
"" ""
religious_minority roma_minority
"" ""
sexual_minority disability_minority
"" ""
suffered_discr gender_docs
"" "logreg"
friends_trans n_friends_minorities
"polyreg" ""
n_actions_against_discri antilgbtq_rights
"" "pmm"
minority_discri
"pmm" age gender
0 0
years_edu community
387 14
marital_status occupation
175 0
social_class religion
1021 483
nonEU_national phone_access
0 0
bill_issues internet_use
379 0
life_sat polintr
102 0
left_right social_alienation
4689 1000
ethnic_minority skincolor_minority
0 0
religious_minority roma_minority
0 0
sexual_minority disability_minority
0 0
suffered_discr gender_docs
0 3187
friends_trans n_friends_minorities
968 0
n_actions_against_discri antilgbtq_rights
0 791
minority_discri
355 age gender
0 0
years_edu community
0 0
marital_status occupation
0 0
social_class religion
0 0
nonEU_national phone_access
0 0
bill_issues internet_use
0 0
life_sat polintr
0 0
left_right social_alienation
0 0
ethnic_minority skincolor_minority
0 0
religious_minority roma_minority
0 0
sexual_minority disability_minority
0 0
suffered_discr gender_docs
0 0
friends_trans n_friends_minorities
0 0
n_actions_against_discri antilgbtq_rights
0 0
minority_discri
0 final_data <- final_data |>
cbind(data$trans_docs) |>
cbind(data$country) |>
rename("trans_docs" = "data$trans_docs",
"country" = "data$country") |>
relocate(country, .before = everything())We know that it would be better to impute multiple datasets and then pool the results of different regressions on those different datasets together, but running more than one multilevel regression would be too computationally intensive and so we are not able to do this.
Joining together all our data
country_level_data stores all our data defined at the country level.
final_data stores all our data (after imputation) for individual level variables.
Explanatory model
To be finished…
Run logistic with all variables and extract only the significant variables
Confirm this is similar to the results we obtain using stepwise regression/lasso regularization
Based on 1 & 2 decide which individual level variables to include in the mixed model
Build the mixed model (look at the mixed model section for further details on how this needs to be built)
Simple logistic regression
I am using only individual level data for now. This is a simple model to see at the global level i.e. no country level control, which variables are significant. The numeric data has also been scaled.
datalr <- final_data |>
# Dropping NAs (there should be NAs only in our target variable)
drop_na() |>
# Selecting only predictor variables
select(-"country") |>
# Scale variables
mutate(across(where(is.numeric), scale)) |>
# Transforming target to binary numeric Yes=1, No=0
mutate(trans_docs = as.numeric(trans_docs == "Yes"))
# now run the full model
simple_logistic <- glm(trans_docs ~ ., data = datalr, family = binomial(link = "logit"))
# Save the summary
logistic_summary <- summary(simple_logistic)
# create a tibble to more easily search through significant variables
logistic_results <- tibble(
broom::tidy(simple_logistic) |>
filter(p.value<0.05) |>
mutate(oddsratio = exp(estimate)) |>
select(term, estimate, oddsratio, p.value) |>
arrange(oddsratio))
logistic_results# A tibble: 26 × 4
term estimate oddsratio p.value
<chr> <dbl> <dbl> <dbl>
1 gender_docsNo -2.66 0.0697 0
2 friends_transRefusal (SPONTANEOUS) -0.798 0.450 2.05e- 5
3 antilgbtq_rights -0.699 0.497 1.16e-194
4 roma_minority1 -0.568 0.567 1.43e- 4
5 internet_useTwo or three times a week -0.418 0.658 4.29e- 8
6 life_satNot at all satisfied -0.395 0.673 3.56e- 4
7 internet_useNever/No access -0.348 0.706 1.92e- 7
8 bill_issuesFrom time to time -0.335 0.716 8.36e- 6
9 internet_useAbout once a week -0.332 0.718 2.13e- 2
10 occupationRetired (4 in d15a) -0.321 0.725 1.24e- 4
# ℹ 16 more rowsInterpeting results
To interpret the coefficients as odds ratios, anything above 1 indicates they are more likely to support the changes to civil documents for trans people.
The logistic regression shows that 26 statistically significant terms. This includes factors variables with multiple terms. Of our 29 scaled variables, the significant variables (at the 5% level) are:
More likely to OPPPOSE the right to change civil documents for trans people, include:
- men (compared to wom)
- younger people
- people who oppose legal rights to add a third-gender in official docs (compared to those who do)
- people who refused to answer whether they have trans friends (compared to those who do)
- people who are more financially sound (have fewer bill issues)
- people not satisfied with their life (compared to those who are ‘very satisfied’)
- people who identified as roma or an ethnic minority
- people who are more discriminatory against minorities
More likely to SUPPORT the the right - older people - women - people who were self-employed (compared to all other occupation types incl students) - unmarried (single) people - non-believers (religious) - people with a landline and mobile - people who use the internet everyday/almost everyday (compared to all other internet use categories) - people who reported being more left wing (compared to right wing) - people who had friends in minority groups.
NUMERIC VARIABLES
Without scaling, we interpret logistic regression output as:
coef(simple_logistic): these coefficients represent the change in the log-odds for a one-unit increase in the corresponding independent variable
exp(coef(simple_logistic)): the exponential of the slope coefficient (exp(B)) tells us the change of the odds if the independent variable increases by one unit
If the data is scaled:
A coefficient B (from a logistic regression) now reflects the change in the log-odds for a one standard deviation increase in the predictor variable, rather than a one-unit increase in the original scale.
The odds ratio (exp(B)) now tells you how the odds change with a one standard deviation increase in the predictor variable, rather than a one-unit increase.
Here we compare the pre and post transformation of coefficients for interpretation:
(Intercept)
2.69303178
age
0.20879798
genderWoman
0.26342657
years_edu
-0.01215087
communitySmall or middle sized town
0.01810837
communityLarge town
-0.04039684 (Intercept)
14.7764069
age
1.2321960
genderWoman
1.3013817
years_edu
0.9879227
communitySmall or middle sized town
1.0182733
communityLarge town
0.9604082 FACTOR VARIABLES
Factor variables when exponentialised give the likelihood to respond no/yes relative to the base group in the factor variable. We use the function factors to view the levels and identify the base group.
To assist with interpretation of factor outputs:
Here is a function to identify all the base levels in each factor group. Useful to refer to during analysis of different logistic models.
extract_base_groups <- function(df) {
# extract factor vars only and list to print values
factor_vars <- names(final_data)[sapply(final_data, is.factor)]
base_groups <- list()
# loop through values to check all levels
for (var in factor_vars) {
if (length(levels(df[[var]])) > 0) { # Check step - should be TRUE for all selected.
contrast_matrix <- contrasts(df[[var]])
if (is.null(contrast_matrix)) {
base_groups[[var]] <- levels(df[[var]])[1] # check only - shouldn't ever run
} else {
base_group_level <- levels(df[[var]])[rowSums(abs(contrast_matrix)) == 0] # base group is the one with all zeroes, so we extract that
base_groups[[var]] <- base_group_level
}
} else {
base_groups[[var]] <- NA # Indicate non-factor or factor with no levels.
}
}
return(base_groups)
}
# run function with 'final data' and print a tidy output
factor_bases <- extract_base_groups(final_data)
factor_bases <- as_tibble(factor_bases) |>
pivot_longer(cols = everything(),
names_to = "vars",
values_to = "base_group")
factor_bases# A tibble: 23 × 2
vars base_group
<chr> <chr>
1 gender Man
2 community Rural area or village
3 marital_status (Re-)Married (1-4 in d7)
4 occupation Self-employed (5 to 9 in d15a)
5 social_class The working class of society
6 religion Catholic
7 nonEU_national 0
8 phone_access Mobile only
9 bill_issues Most of the time
10 internet_use Everyday/Almost everyday
# ℹ 13 more rowsModel performance - Simple logistic
Here, we test the models ability to classify people as supporting or not supporting the rights.
# AIC of model
simple_logistic$aic[1] 19544.18#predicted probabilities of being a 1 (i.e. a refusal of possibility of trans doc)
predicted_probs <- simple_logistic$fitted.values
# same by running
# predicted_probs <- predict(simple_logistic, type = "response")
head(predicted_probs) 1 2 3 4 5 6
0.3463520 0.4321645 0.5170989 0.5799662 0.9141149 0.5131253 # Turning them to classes using custom threshold
predicted_classes <- ifelse(predicted_probs > 0.5, 1, 0)
head(predicted_classes)1 2 3 4 5 6
0 0 1 1 1 1 Get the confusion matrix:
confusionMatrix(as.factor(datalr$trans_docs), as.factor(predicted_classes))Confusion Matrix and Statistics
Reference
Prediction 0 1
0 7608 2087
1 2246 12217
Accuracy : 0.8206
95% CI : (0.8157, 0.8255)
No Information Rate : 0.5921
P-Value [Acc > NIR] : < 2e-16
Kappa : 0.6277
Mcnemar's Test P-Value : 0.01638
Sensitivity : 0.7721
Specificity : 0.8541
Pos Pred Value : 0.7847
Neg Pred Value : 0.8447
Prevalence : 0.4079
Detection Rate : 0.3149
Detection Prevalence : 0.4013
Balanced Accuracy : 0.8131
'Positive' Class : 0
The simple model predicted people’s response with 82% accuracy. That is quite decent for a basic first model. This shows the response is quite explainable with the data we have. The model is slightly better at predicting those who do not support than those who do. Seen by higher specificity than sensitivity (85% vs 77%). But they are both comparable which is good and confirms we don’t have great class imbalance.
roc_obj <- roc(datalr$trans_docs, predicted_probs)
# Terrible graphs, do we have better ones? Not sure. I think the first is good enough.
pROC::ggroc(roc_obj)
plot(roc_obj)
coords(roc_obj, "best") threshold specificity sensitivity
1 0.5937607 0.843115 0.7938187auc(datalr$trans_docs, predicted_probs)Area under the curve: 0.8937Stepwise regression
Chooses the best simple logistic model based on the lowest AIC achievable
Call: glm(formula = trans_docs ~ age + gender + marital_status + occupation +
religion + phone_access + bill_issues + internet_use + life_sat +
left_right + ethnic_minority + roma_minority + suffered_discr +
gender_docs + friends_trans + n_friends_minorities + n_actions_against_discri +
antilgbtq_rights + minority_discri, family = binomial(link = "logit"),
data = datalr)
Coefficients:
(Intercept)
2.62467
age
0.20698
genderWoman
0.26440
marital_statusSingle living with partner (5-8 in d7)
0.04042
marital_statusSingle (9-10 in d7)
0.13987
marital_statusDivorced or separated (11-12 in d7)
0.10517
marital_statusWidow (13-14 in d7)
-0.10979
occupationManagers (10 to 12 in d15a)
0.01744
occupationOther white collars (13 or 14 in d15a)
-0.25937
occupationManual workers (15 to 18 in d15a)
-0.14375
occupationHouse persons (1 in d15a)
0.05889
occupationUnemployed (3 in d15a)
-0.12589
occupationRetired (4 in d15a)
-0.30665
occupationStudents (2 in d15a)
-0.29364
religionOrthodox Christian
-0.12432
religionProtestant
0.08546
religionOther Christian
-0.13836
religionOther
0.06244
religionMuslim
-0.24374
religionNon-believers
0.13104
phone_accessLandline only
-0.09735
phone_accessLandline & mobile
0.27311
phone_accessNo telephone
-0.19336
bill_issuesFrom time to time
-0.34079
bill_issuesAlmost never/never
-0.22203
internet_useTwo or three times a week
-0.41597
internet_useAbout once a week
-0.31328
internet_useTwo or three times a month
-0.09201
internet_useLess often
0.02229
internet_useNever/No access
-0.33028
internet_useNo Internet access at all
-0.02332
life_satFairly satisfied
0.05142
life_satNot very satisfied
-0.14512
life_satNot at all satisfied
-0.38741
left_right(5 - 6) Centre
0.05631
left_right(7 -10) Right
-0.17298
ethnic_minority1
-0.26298
roma_minority1
-0.58673
suffered_discr1
-0.22381
gender_docsNo
-2.65983
friends_transNo
-0.13252
friends_transRefusal (SPONTANEOUS)
-0.79810
n_friends_minorities
0.15912
n_actions_against_discri
0.03980
antilgbtq_rights
-0.69753
minority_discri
-0.23593
Degrees of Freedom: 24157 Total (i.e. Null); 24112 Residual
Null Deviance: 32540
Residual Deviance: 19430 AIC: 19530The stepwise regression has 19 of the 29 variables included in it’s best model. It is quite consistent with what our significant variables were above, so we will not provide further commentary. Compared to the full model, this reduced model does not provide a statistically significant improvement in fit. But it does give us a more simple model and shows us what individual level variable may be most important overall.
anova(simple_logistic, stepAIC)Analysis of Deviance Table
Model 1: trans_docs ~ age + gender + years_edu + community + marital_status +
occupation + social_class + religion + nonEU_national + phone_access +
bill_issues + internet_use + life_sat + polintr + left_right +
social_alienation + ethnic_minority + skincolor_minority +
religious_minority + roma_minority + sexual_minority + disability_minority +
suffered_discr + gender_docs + friends_trans + n_friends_minorities +
n_actions_against_discri + antilgbtq_rights + minority_discri
Model 2: trans_docs ~ age + gender + marital_status + occupation + religion +
phone_access + bill_issues + internet_use + life_sat + left_right +
ethnic_minority + roma_minority + suffered_discr + gender_docs +
friends_trans + n_friends_minorities + n_actions_against_discri +
antilgbtq_rights + minority_discri
Resid. Df Resid. Dev Df Deviance Pr(>Chi)
1 24096 19420
2 24112 19434 -16 -14.121 0.5897DIEGO: ask for an explanation of this
Lasso regularization
We still have too many variables for a mixed model. So here we will use Lasso to keep only our most important variables for the mixed models.
Without this step, the glmer stage is too computationally expensive.
lasso_data <- final_data |>
# Doing same preprocessing as done for simple logistic
drop_na() |>
select(-"country") |>
mutate(across(where(is.numeric), scale)) |>
mutate(trans_docs = as.numeric(trans_docs == "Yes"))
# Dummifying all levels to see whether some levels are particularly important
lasso_data <- lasso_data %>%
dummy_cols(select_columns = names(.)[sapply(., is.factor)],
remove_selected_columns = TRUE,
remove_first_dummy = TRUE)
# Convert data into a matrix for glmnet
x_lasso <- lasso_data |> select(-trans_docs) |> as.matrix()
y_lasso <- lasso_data |> select(trans_docs) |> as.matrix()
set.seed(123)
# Define lamdas
lambda_seq <- 10^seq(-2, -5, length.out = 100)
# Fit the Lasso model (alpha = 1 for Lasso regularization)
lasso_model <- cv.glmnet(x_lasso, y_lasso, family = "binomial", alpha = 1, lambda = lambda_seq)
lasso_model$lambda.1se # The largest lambda within one standard error of lambda.min. This results in a simpler model with fewer selected features.[1] 0.007564633lasso_model$lambda.min[1] 0.0006579332# Get all the coefficients
coefficients <- coef(lasso_model, s = "lambda.1se")
# Filter for the non-zero ones
non_zero_features <- rownames(coefficients)[which(coefficients != 0)]
non_zero_features [1] "(Intercept)"
[2] "age"
[3] "n_friends_minorities"
[4] "antilgbtq_rights"
[5] "minority_discri"
[6] "gender_Woman"
[7] "occupation_Managers (10 to 12 in d15a)"
[8] "religion_Orthodox Christian"
[9] "phone_access_Landline & mobile"
[10] "bill_issues_From time to time"
[11] "internet_use_Two or three times a week"
[12] "internet_use_Never/No access"
[13] "life_sat_Not very satisfied"
[14] "life_sat_Not at all satisfied"
[15] "left_right_(7 -10) Right"
[16] "ethnic_minority_1"
[17] "roma_minority_1"
[18] "suffered_discr_1"
[19] "gender_docs_No"
[20] "friends_trans_Refusal (SPONTANEOUS)" Lasso includes variables similar to what was suggested by our initial logistic regression and the subsequent stepwise.
In particular we can see again that:
ageis relevantgenderis relevantIt matters whether you have friends that belong to minorites (
n_friends_minorities)
Also `ant
Final variable selection
From these hints above and general intuition, we will select the following variables as our individual level fixed effects in the mixed level model:
- age
- gender
- religion (to be recoded as non-believer dummy since that’s the significant variable)
- bill_issues
- internet use (recoded to everyday or not)
- left_right
- ethnic minority + roma minority (recoded to one dummy)
- trans_friends
- lgbti_docs
- minority_discri
And these are our pre-defined fixed
Mixed model
Random Intercept Model:
Allows the baseline level (intercept) to vary across groups. Assumes the relationship between predictors and outcome (slope) is the same for all groups
In R syntax: y ~ x + (1|group)
Example: Different schools might have different average test scores (random intercepts), but the effect of study hours on test scores is the same across all schools
Random Slope Model:
Allows the effect of a predictor (slope) to vary across groups. Can be used with or without random intercepts.
In R syntax: y ~ x + (0+x|group) for random slope only, or y ~ x + (1+x|group) for both random intercept and slope
Example: The effect of study hours on test scores might be stronger in some schools than others (random slopes)
Random intercept models account for different baselines between groups, while random slope models account for different relationships between predictors and outcomes across groups. When both random intercepts and slopes are included, you’re allowing both the baseline and the effect of predictors to vary by group.
Interactions between group-level (higher-level) variables and individual-level (lower-level) variables in mixed models are called cross-level interactions.
Cross-level interactions are particularly useful in multilevel research because they help you understand how the relationship between an individual-level predictor and the outcome varies as a function of a group-level characteristic.
For example, in educational research: 1) Individual level: student characteristics (study time, prior knowledge). 2) Group level: school or classroom characteristics (class size, teaching method). 3) Cross-level interaction: Does the effect of study time on performance depend on class size?
Running the glmer models
To model, we will follow: Approach to multilevel model building based on Hox (2010)
1/ Null Model (Random Intercept only) 2/ Add independent Level 1 variables 3/ Add independent Level 2 variables 4/ Add random slopes 5/ (Cross-level) interactions
Each step, check whether your model is significantly improved compared to the previous one.
We could run these different models and select the best one: null_glmer -> only country random effects for a baseline glmer_stepwise -> using the best stepwise model best model for individual fixed effects + adding country random effects glmer_lasso -> using the lasso model fixed individual level effects + country glmer_level2 -> using the best model from above and adding in all country level fixed effects too glmer_cross_level -> the model using integrated
# Switching to df containing both individual and country level
complete_df <- complete_df |>
drop_na() # should be zero as we cleaned before but just in case
# Scaling the variables speeds up the running time. However we loose interpretation? maybe the best thing to do is to center them rather than scaling?
scaled_df <- complete_df |>
mutate(across(where(is.numeric), scale))
# include glmer null model for comparison for improvements - only has random intercept
null_glmer_model <- glmer(trans_docs ~ (1|country),
data = scaled_df,
family=binomial(link="logit"))
## running the level 1 glmer model (indiviudal fixed effects + country random effects)
# variable selection from the stepwise model output
# this took 7.6 minutes to run WITH the scaled data, saved output locally
# start <- Sys.time()
# glmer_model_level1 <- glmer(
# # target
# trans_docs ~
# #individual data - significant from stepwise testing
# age + gender + marital_status + occupation +
# religion + phone_access + bill_issues + internet_use + life_sat +
# left_right + ethnic_minority + roma_minority + suffered_discr +
# gender_docs + friends_trans + n_friends_minorities + n_actions_against_discri +
# antilgbtq_rights + minority_discri + (1|country),
# data = scaled_df,
# family = binomial(link="logit")
# )
# end <- Sys.time()
# end-start
# glmer_model_level1
# output_glmer_1 <- broom.mixed::tidy(glmer_model_level1)
## running the level 2 glmer model (individual & country fixed effects + country random effects)
# took 10.8 minutes to run so commented out. Saved output locally
# start <- Sys.time()
# glmer_model_level2 <- glmer(
# # target variable
# trans_docs ~
# #individual level fixed effects
# age + gender + marital_status + occupation +
# religion + phone_access + bill_issues + internet_use + life_sat +
# left_right + ethnic_minority + roma_minority + suffered_discr +
# gender_docs + friends_trans + n_friends_minorities + n_actions_against_discri +
# antilgbtq_rights + minority_discri +
# #country level fixed effects
# gdp_pc_ppp + gender_inequality_index + lgbt_policy_index + democracy_index +
# # random effects of country
# (1|country),
# data = scaled_df,
# family = binomial(link="logit")
# )
# end <- Sys.time()
# end-start
# output_glmer_2 <- broom.mixed::tidy(glmer_model_level2)
# glmer model with cross-level interactions
glmer_model <- glmer(trans_docs ~ gender:lgbt_policy_index + gender*gender_inequality_index + religion*gdp_pc_ppp + (1 | country), data=scaled_df, family=binomial(link="logit"))
## saving the level1 and level2 outputs to file for review of full model effects
#write_csv2(output_glmer_1, "glmer_level1_model_output.csv")
#write_csv2(output_glmer_2, "glmer_level2_model_output.csv")
## writing output for AIC/BIC and saving too
# glmer_compare <- anova(null_glmer_model, glmer_model_level1, glmer_model_level2, glmer_model)
# write_csv2(glmer_compare, "glmer_compare_basicmodels.csv")
#variable1*variable2 includes both the two variables separetely and their interaction
#variable1:variable2 includes only the interaction
#+ (1|country) country is the grouping variable, means it includes different intercepts for each country
summary(glmer_model) # print in better tables as Marga likesGeneralized linear mixed model fit by maximum likelihood (Laplace
Approximation) [glmerMod]
Family: binomial ( logit )
Formula:
trans_docs ~ gender:lgbt_policy_index + gender * gender_inequality_index +
religion * gdp_pc_ppp + (1 | country)
Data: scaled_df
AIC BIC logLik deviance df.resid
27760.0 27921.9 -13860.0 27720.0 24138
Scaled residuals:
Min 1Q Median 3Q Max
-2.7416 -0.6925 -0.4228 0.8840 4.3145
Random effects:
Groups Name Variance Std.Dev.
country (Intercept) 0.2811 0.5302
Number of obs: 24158, groups: country, 28
Fixed effects:
Estimate Std. Error z value
(Intercept) -0.13251 0.10579 -1.253
genderWoman -0.45316 0.03005 -15.079
gender_inequality_index 0.24291 0.13625 1.783
religionOrthodox Christian 0.14645 0.08187 1.789
religionProtestant -0.13895 0.06647 -2.091
religionOther Christian 0.12570 0.07721 1.628
religionOther -0.21751 0.07081 -3.072
religionMuslim 0.30067 0.12733 2.361
religionNon-believers -0.56486 0.04553 -12.407
gdp_pc_ppp -0.17017 0.10534 -1.615
genderMan:lgbt_policy_index -0.43635 0.12779 -3.414
genderWoman:lgbt_policy_index -0.56817 0.12769 -4.450
genderWoman:gender_inequality_index 0.03764 0.04140 0.909
religionOrthodox Christian:gdp_pc_ppp 0.16990 0.09189 1.849
religionProtestant:gdp_pc_ppp 0.15571 0.08005 1.945
religionOther Christian:gdp_pc_ppp 0.04970 0.08077 0.615
religionOther:gdp_pc_ppp 0.10347 0.06959 1.487
religionMuslim:gdp_pc_ppp 0.24140 0.12339 1.956
religionNon-believers:gdp_pc_ppp 0.01368 0.04644 0.294
Pr(>|z|)
(Intercept) 0.210336
genderWoman < 2e-16 ***
gender_inequality_index 0.074613 .
religionOrthodox Christian 0.073659 .
religionProtestant 0.036564 *
religionOther Christian 0.103541
religionOther 0.002129 **
religionMuslim 0.018209 *
religionNon-believers < 2e-16 ***
gdp_pc_ppp 0.106205
genderMan:lgbt_policy_index 0.000639 ***
genderWoman:lgbt_policy_index 8.6e-06 ***
genderWoman:gender_inequality_index 0.363264
religionOrthodox Christian:gdp_pc_ppp 0.064484 .
religionProtestant:gdp_pc_ppp 0.051760 .
religionOther Christian:gdp_pc_ppp 0.538373
religionOther:gdp_pc_ppp 0.137032
religionMuslim:gdp_pc_ppp 0.050425 .
religionNon-believers:gdp_pc_ppp 0.768383
---
Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1# To calculate the intraclass coefficient (ICC) for the model, we use the ICC function from performance.
# Calculate ICC for the null model, we get around 22% explained
performance::icc(null_glmer_model)# Intraclass Correlation Coefficient
Adjusted ICC: 0.227
Unadjusted ICC: 0.227# When we run for the model with scaled data, we get 7% ICC
performance::icc(glmer_model)# Intraclass Correlation Coefficient
Adjusted ICC: 0.079
Unadjusted ICC: 0.064# this gives us the following significant variables: age, gender, occupation, religion, phone_access, bill_issues, internet_use, left_right, ethnic_minority_
# we exclude these non significant variable: martial_status, The idea is to run interactions between individual level variables and country level variables choosing pair which make sense (ex. does the effect of being female on support for trans docs depend on the gender equality index? –> did this by doing gender*gender_inequality_index)
Let’s use our brain and common sense to choose the best combinations
Predictive model
Summarize individual data to a country level (ex. percentage of population living in rural areas by country, percentage of people from minority x by country)
Run random forest/gradient boosting/logistic regression with leave-one-out cross validation
Leave-One-Out Cross-Validation (LOOCV): LOOCV is a special case of k-fold cross-validation, where k = the number of observations (n).
That means: For each observation (1 out of 28), the model is trained on the remaining 27 rows and tested on the left-out row. This process repeats 28 times (once per row). The final performance metric (e.g., accuracy, RMSE) is the average of all 28 test results.
Aggregating individual data to country level
We should be building a dataframe with 28 rows (1 per country), but many variables (ex, percentage of christian people by country, percentage of very satisfied with lives people by country, percentage of people that belong to the roma minority etc.; our target variable would become % of people that support trans_docs by country)
In the next steps we will synthesize the information from the individual respondents into country-level variables.
Using means for numeric variables:
names(select(final_data, where(is.numeric))) # using final_data because it still has "country", which we dropped for complete_df[1] "age" "years_edu"
[3] "social_alienation" "n_friends_minorities"
[5] "n_actions_against_discri" "antilgbtq_rights"
[7] "minority_discri" As well as for dummies:
# searching for factor variables with two levels
dummy_names <- names(final_data)[sapply(final_data, is.factor) & sapply(final_data, function(x) length(levels(x)) == 2)]
dummy_names [1] "gender" "nonEU_national" "ethnic_minority"
[4] "skincolor_minority" "religious_minority" "roma_minority"
[7] "sexual_minority" "disability_minority" "suffered_discr"
[10] "gender_docs" "trans_docs" dummy_levels <- lapply(final_data[dummy_names], levels)
dummy_levels$gender
[1] "Man" "Woman"
$nonEU_national
[1] "0" "1"
$ethnic_minority
[1] "0" "1"
$skincolor_minority
[1] "0" "1"
$religious_minority
[1] "0" "1"
$roma_minority
[1] "0" "1"
$sexual_minority
[1] "0" "1"
$disability_minority
[1] "0" "1"
$suffered_discr
[1] "0" "1"
$gender_docs
[1] "Yes" "No"
$trans_docs
[1] "Yes" "No" gender nonEU_national ethnic_minority
0 0 0
skincolor_minority religious_minority roma_minority
0 0 0
sexual_minority disability_minority suffered_discr
0 0 0
gender_docs trans_docs
0 3280 After imputations only the target variable should have NAs. They have already been dropped before so no variable has NAs
data_dummy <- final_data %>%
select(country, all_of(dummy_names)) %>%
mutate(across(all_of(dummy_names),
~ case_when(
. %in% c("0", "1") ~ as.numeric(as.character(.)), # convert "0"/"1" to 0/1
. %in% c("Yes", "No") ~ recode(., "Yes" = 1, "No" = 0), # convert "Yes"/"No" to 1/0
. %in% c("Man", "Woman") ~ recode(., "Man" = 1, "Woman" = 0), # convert "Man"/"Woman" to 1/0
TRUE ~ NA # assign NA to other unexpected values
),
.names = "{.col}_num"))
colSums(is.na(data_dummy)) # The warning is weird as there seem to be no NAs country gender
0 0
nonEU_national ethnic_minority
0 0
skincolor_minority religious_minority
0 0
roma_minority sexual_minority
0 0
disability_minority suffered_discr
0 0
gender_docs trans_docs
0 3280
gender_num nonEU_national_num
0 0
ethnic_minority_num skincolor_minority_num
0 0
religious_minority_num roma_minority_num
0 0
sexual_minority_num disability_minority_num
0 0
suffered_discr_num gender_docs_num
0 0
trans_docs_num
3280 I converted factors with 2 levels to numerical 0-1 so we can compute their means.
Deleted the column calculating the % of NAs in trans_doc because although useful those NAs had already been dropped so it was returning all 0s
# country means
data_dummy <- data_dummy %>%
group_by(country) %>%
summarise(
across(ends_with("_num"), ~ mean(.x, na.rm = TRUE)),
.groups = "drop"
)
# substitute the "_num" suffix with a "mean_" prefix so it has the same format as the variables in data_num
data_dummy <- data_dummy %>%
rename_with(~ paste0("mean_", str_remove(., "_num$")), ends_with("_num"))
colSums(is.na(data_dummy)) country mean_gender
0 0
mean_nonEU_national mean_ethnic_minority
0 0
mean_skincolor_minority mean_religious_minority
0 0
mean_roma_minority mean_sexual_minority
0 0
mean_disability_minority mean_suffered_discr
0 0
mean_gender_docs mean_trans_docs
0 0 Now we can join the two datasets.
The next variables are factor with >2 levels:
factor_names <- names(final_data)[!sapply(final_data, is.numeric) &
!(sapply(final_data, is.factor) & sapply(final_data, function(x) length(levels(x)) == 2))]
factor_names [1] "country" "community" "marital_status"
[4] "occupation" "social_class" "religion"
[7] "phone_access" "bill_issues" "internet_use"
[10] "life_sat" "polintr" "left_right"
[13] "friends_trans" # checking the levels
lapply(final_data[factor_names], levels)$country
NULL
$community
[1] "Rural area or village" "Small or middle sized town"
[3] "Large town"
$marital_status
[1] "(Re-)Married (1-4 in d7)"
[2] "Single living with partner (5-8 in d7)"
[3] "Single (9-10 in d7)"
[4] "Divorced or separated (11-12 in d7)"
[5] "Widow (13-14 in d7)"
$occupation
[1] "Self-employed (5 to 9 in d15a)"
[2] "Managers (10 to 12 in d15a)"
[3] "Other white collars (13 or 14 in d15a)"
[4] "Manual workers (15 to 18 in d15a)"
[5] "House persons (1 in d15a)"
[6] "Unemployed (3 in d15a)"
[7] "Retired (4 in d15a)"
[8] "Students (2 in d15a)"
$social_class
[1] "The working class of society"
[2] "The lower middle class of society"
[3] "The middle class of society"
[4] "The upper middle class of society"
[5] "The higher class of society"
$religion
[1] "Catholic" "Orthodox Christian" "Protestant"
[4] "Other Christian" "Other" "Muslim"
[7] "Non-believers"
$phone_access
[1] "Mobile only" "Landline only" "Landline & mobile"
[4] "No telephone"
$bill_issues
[1] "Most of the time" "From time to time" "Almost never/never"
$internet_use
[1] "Everyday/Almost everyday" "Two or three times a week"
[3] "About once a week" "Two or three times a month"
[5] "Less often" "Never/No access"
[7] "No Internet access at all"
$life_sat
[1] "Very satisfied" "Fairly satisfied"
[3] "Not very satisfied" "Not at all satisfied"
$polintr
[1] "Strong" "Medium" "Low" "Not at all"
$left_right
[1] "(1 - 4) Left" "(5 - 6) Centre" "(7 -10) Right"
$friends_trans
[1] "Yes" "No"
[3] "Refusal (SPONTANEOUS)"# removing country from the list
factor_names <- setdiff(factor_names, "country")
# creating the aggregated dataset for factor variables
data_factors <- final_data %>%
select(country, all_of(factor_names)) %>%
pivot_longer(cols = -country, names_to = "variable", values_to = "level") %>%
group_by(country, variable, level) %>%
summarise(count = n(), .groups = "drop") %>%
group_by(country, variable) %>%
mutate(proportion = count / sum(count)) %>%
select(-count) %>%
pivot_wider(names_from = c(variable, level), values_from = proportion, names_glue = "{variable}_{level}")
colSums(is.na(data_factors)) country
0
bill_issues_Most of the time
0
bill_issues_From time to time
0
bill_issues_Almost never/never
0
community_Rural area or village
0
community_Small or middle sized town
0
community_Large town
0
friends_trans_Yes
0
friends_trans_No
0
friends_trans_Refusal (SPONTANEOUS)
0
internet_use_Everyday/Almost everyday
0
internet_use_Two or three times a week
0
internet_use_About once a week
1
internet_use_Two or three times a month
0
internet_use_Less often
0
internet_use_Never/No access
0
internet_use_No Internet access at all
0
left_right_(1 - 4) Left
0
left_right_(5 - 6) Centre
0
left_right_(7 -10) Right
0
life_sat_Very satisfied
0
life_sat_Fairly satisfied
0
life_sat_Not very satisfied
0
life_sat_Not at all satisfied
0
marital_status_(Re-)Married (1-4 in d7)
0
marital_status_Single living with partner (5-8 in d7)
0
marital_status_Single (9-10 in d7)
0
marital_status_Divorced or separated (11-12 in d7)
0
marital_status_Widow (13-14 in d7)
0
occupation_Self-employed (5 to 9 in d15a)
0
occupation_Managers (10 to 12 in d15a)
0
occupation_Other white collars (13 or 14 in d15a)
0
occupation_Manual workers (15 to 18 in d15a)
0
occupation_House persons (1 in d15a)
0
occupation_Unemployed (3 in d15a)
0
occupation_Retired (4 in d15a)
0
occupation_Students (2 in d15a)
0
phone_access_Mobile only
0
phone_access_Landline only
0
phone_access_Landline & mobile
0
phone_access_No telephone
1
polintr_Strong
0
polintr_Medium
0
polintr_Low
0
polintr_Not at all
0
religion_Catholic
0
religion_Orthodox Christian
0
religion_Protestant
1
religion_Other Christian
2
religion_Other
0
religion_Muslim
4
religion_Non-believers
0
social_class_The working class of society
0
social_class_The lower middle class of society
0
social_class_The middle class of society
0
social_class_The upper middle class of society
0
social_class_The higher class of society
3 We are seeing NAs because in not all countries are all the factors’ levels represented. For example we see that social_class_The higher class of society has 3 missing values. Let’s confirm that there are 3 countries in our dataframe with no observation for that level
final_data |> filter(social_class=="The higher class of society") |> pull(country) |> unique() |> length()[1] 25Therefore those proportions should be 0s and not NAs
data_factors <- data_factors |>
mutate(across(everything(), ~replace_na(., 0)))Joining all together
data_aggr <- data_aggr |>
left_join(data_factors, by = "country")Lastly, joining the country level variables obtained from external sources
country
0
mean_age
0
mean_years_edu
0
mean_social_alienation
0
mean_n_friends_minorities
0
mean_n_actions_against_discri
0
mean_antilgbtq_rights
0
mean_minority_discri
0
mean_gender
0
mean_nonEU_national
0
mean_ethnic_minority
0
mean_skincolor_minority
0
mean_religious_minority
0
mean_roma_minority
0
mean_sexual_minority
0
mean_disability_minority
0
mean_suffered_discr
0
mean_gender_docs
0
mean_trans_docs
0
bill_issues_Most of the time
0
bill_issues_From time to time
0
bill_issues_Almost never/never
0
community_Rural area or village
0
community_Small or middle sized town
0
community_Large town
0
friends_trans_Yes
0
friends_trans_No
0
friends_trans_Refusal (SPONTANEOUS)
0
internet_use_Everyday/Almost everyday
0
internet_use_Two or three times a week
0
internet_use_About once a week
0
internet_use_Two or three times a month
0
internet_use_Less often
0
internet_use_Never/No access
0
internet_use_No Internet access at all
0
left_right_(1 - 4) Left
0
left_right_(5 - 6) Centre
0
left_right_(7 -10) Right
0
life_sat_Very satisfied
0
life_sat_Fairly satisfied
0
life_sat_Not very satisfied
0
life_sat_Not at all satisfied
0
marital_status_(Re-)Married (1-4 in d7)
0
marital_status_Single living with partner (5-8 in d7)
0
marital_status_Single (9-10 in d7)
0
marital_status_Divorced or separated (11-12 in d7)
0
marital_status_Widow (13-14 in d7)
0
occupation_Self-employed (5 to 9 in d15a)
0
occupation_Managers (10 to 12 in d15a)
0
occupation_Other white collars (13 or 14 in d15a)
0
occupation_Manual workers (15 to 18 in d15a)
0
occupation_House persons (1 in d15a)
0
occupation_Unemployed (3 in d15a)
0
occupation_Retired (4 in d15a)
0
occupation_Students (2 in d15a)
0
phone_access_Mobile only
0
phone_access_Landline only
0
phone_access_Landline & mobile
0
phone_access_No telephone
0
polintr_Strong
0
polintr_Medium
0
polintr_Low
0
polintr_Not at all
0
religion_Catholic
0
religion_Orthodox Christian
0
religion_Protestant
0
religion_Other Christian
0
religion_Other
0
religion_Muslim
0
religion_Non-believers
0
social_class_The working class of society
0
social_class_The lower middle class of society
0
social_class_The middle class of society
0
social_class_The upper middle class of society
0
social_class_The higher class of society
0
gdp_pc_ppp
0
gender_inequality_index
0
lgbt_policy_index
0
democracy_index
0 dim(data_aggr)[1] 28 79The resulting data frame has 28 observations and 79 variables. We might have to clean the names of the variables that were glued from variable_level.
Linear regression with LASSO
data_models <- data_aggr |>
select(-country)
# Define the leave-one-out cross-validation control
ctrl <- trainControl(
method = "LOOCV",
verboseIter = TRUE
)
# # LASSO
# # Set up the grid of lambda values for Lasso
# lambda_grid <- 10^seq(-3, 3, length = 100)
#
# # Train the Lasso model with LOOCV
# lasso_model <- train(
# mean_trans_docs ~ .,
# data = data_models,
# method = "glmnet",
# preProc=c('scale','center'),
# trControl = ctrl,
# tuneGrid = expand.grid(
# alpha = 1, # 1 for Lasso
# lambda = lambda_grid
# ),
# importance = TRUE,
# metric = "RMSE"
# )
# # Print the best tuning parameter (lambda)
# print(lasso_model$bestTune)
#
# # Summarize the final model
# print(lasso_model)
#
# # Examine variable importance
# importance <- varImp(lasso_model, scale = FALSE)
# print(importance)
# plot(importance, top = 20)
#
# # Get the coefficients of the best model
# best_model <- lasso_model$finalModel
# coef_lasso <- coef(best_model, s = best_lambda)
# print(coef_lasso)
# ELASTIC
elastic_grid <- expand.grid(
alpha = seq(0, 1, length = 10), # Search from Ridge (0) to Lasso (1)
lambda = 10^seq(-3, 3, length = 100) # Regularization strength
)
# Train the Elastic Net model
elastic_net_model <- train(
mean_trans_docs ~ .,
data = data_models,
method = "glmnet",
preProcess = c("center", "scale"),
trControl = ctrl,
tuneGrid = elastic_grid,
metric = "RMSE"
)+ Fold01: alpha=0.0000000, lambda=1000
- Fold01: alpha=0.0000000, lambda=1000
+ Fold01: alpha=0.1111111, lambda=1000
- Fold01: alpha=0.1111111, lambda=1000
+ Fold01: alpha=0.2222222, lambda=1000
- Fold01: alpha=0.2222222, lambda=1000
+ Fold01: alpha=0.3333333, lambda=1000
- Fold01: alpha=0.3333333, lambda=1000
+ Fold01: alpha=0.4444444, lambda=1000
- Fold01: alpha=0.4444444, lambda=1000
+ Fold01: alpha=0.5555556, lambda=1000
- Fold01: alpha=0.5555556, lambda=1000
+ Fold01: alpha=0.6666667, lambda=1000
- Fold01: alpha=0.6666667, lambda=1000
+ Fold01: alpha=0.7777778, lambda=1000
- Fold01: alpha=0.7777778, lambda=1000
+ Fold01: alpha=0.8888889, lambda=1000
- Fold01: alpha=0.8888889, lambda=1000
+ Fold01: alpha=1.0000000, lambda=1000
- Fold01: alpha=1.0000000, lambda=1000
+ Fold02: alpha=0.0000000, lambda=1000
- Fold02: alpha=0.0000000, lambda=1000
+ Fold02: alpha=0.1111111, lambda=1000
- Fold02: alpha=0.1111111, lambda=1000
+ Fold02: alpha=0.2222222, lambda=1000
- Fold02: alpha=0.2222222, lambda=1000
+ Fold02: alpha=0.3333333, lambda=1000
- Fold02: alpha=0.3333333, lambda=1000
+ Fold02: alpha=0.4444444, lambda=1000
- Fold02: alpha=0.4444444, lambda=1000
+ Fold02: alpha=0.5555556, lambda=1000
- Fold02: alpha=0.5555556, lambda=1000
+ Fold02: alpha=0.6666667, lambda=1000
- Fold02: alpha=0.6666667, lambda=1000
+ Fold02: alpha=0.7777778, lambda=1000
- Fold02: alpha=0.7777778, lambda=1000
+ Fold02: alpha=0.8888889, lambda=1000
- Fold02: alpha=0.8888889, lambda=1000
+ Fold02: alpha=1.0000000, lambda=1000
- Fold02: alpha=1.0000000, lambda=1000
+ Fold03: alpha=0.0000000, lambda=1000
- Fold03: alpha=0.0000000, lambda=1000
+ Fold03: alpha=0.1111111, lambda=1000
- Fold03: alpha=0.1111111, lambda=1000
+ Fold03: alpha=0.2222222, lambda=1000
- Fold03: alpha=0.2222222, lambda=1000
+ Fold03: alpha=0.3333333, lambda=1000
- Fold03: alpha=0.3333333, lambda=1000
+ Fold03: alpha=0.4444444, lambda=1000
- Fold03: alpha=0.4444444, lambda=1000
+ Fold03: alpha=0.5555556, lambda=1000
- Fold03: alpha=0.5555556, lambda=1000
+ Fold03: alpha=0.6666667, lambda=1000
- Fold03: alpha=0.6666667, lambda=1000
+ Fold03: alpha=0.7777778, lambda=1000
- Fold03: alpha=0.7777778, lambda=1000
+ Fold03: alpha=0.8888889, lambda=1000
- Fold03: alpha=0.8888889, lambda=1000
+ Fold03: alpha=1.0000000, lambda=1000
- Fold03: alpha=1.0000000, lambda=1000
+ Fold04: alpha=0.0000000, lambda=1000
- Fold04: alpha=0.0000000, lambda=1000
+ Fold04: alpha=0.1111111, lambda=1000
- Fold04: alpha=0.1111111, lambda=1000
+ Fold04: alpha=0.2222222, lambda=1000
- Fold04: alpha=0.2222222, lambda=1000
+ Fold04: alpha=0.3333333, lambda=1000
- Fold04: alpha=0.3333333, lambda=1000
+ Fold04: alpha=0.4444444, lambda=1000
- Fold04: alpha=0.4444444, lambda=1000
+ Fold04: alpha=0.5555556, lambda=1000
- Fold04: alpha=0.5555556, lambda=1000
+ Fold04: alpha=0.6666667, lambda=1000
- Fold04: alpha=0.6666667, lambda=1000
+ Fold04: alpha=0.7777778, lambda=1000
- Fold04: alpha=0.7777778, lambda=1000
+ Fold04: alpha=0.8888889, lambda=1000
- Fold04: alpha=0.8888889, lambda=1000
+ Fold04: alpha=1.0000000, lambda=1000
- Fold04: alpha=1.0000000, lambda=1000
+ Fold05: alpha=0.0000000, lambda=1000
- Fold05: alpha=0.0000000, lambda=1000
+ Fold05: alpha=0.1111111, lambda=1000
- Fold05: alpha=0.1111111, lambda=1000
+ Fold05: alpha=0.2222222, lambda=1000
- Fold05: alpha=0.2222222, lambda=1000
+ Fold05: alpha=0.3333333, lambda=1000
- Fold05: alpha=0.3333333, lambda=1000
+ Fold05: alpha=0.4444444, lambda=1000
- Fold05: alpha=0.4444444, lambda=1000
+ Fold05: alpha=0.5555556, lambda=1000
- Fold05: alpha=0.5555556, lambda=1000
+ Fold05: alpha=0.6666667, lambda=1000
- Fold05: alpha=0.6666667, lambda=1000
+ Fold05: alpha=0.7777778, lambda=1000
- Fold05: alpha=0.7777778, lambda=1000
+ Fold05: alpha=0.8888889, lambda=1000
- Fold05: alpha=0.8888889, lambda=1000
+ Fold05: alpha=1.0000000, lambda=1000
- Fold05: alpha=1.0000000, lambda=1000
+ Fold06: alpha=0.0000000, lambda=1000
- Fold06: alpha=0.0000000, lambda=1000
+ Fold06: alpha=0.1111111, lambda=1000
- Fold06: alpha=0.1111111, lambda=1000
+ Fold06: alpha=0.2222222, lambda=1000
- Fold06: alpha=0.2222222, lambda=1000
+ Fold06: alpha=0.3333333, lambda=1000
- Fold06: alpha=0.3333333, lambda=1000
+ Fold06: alpha=0.4444444, lambda=1000
- Fold06: alpha=0.4444444, lambda=1000
+ Fold06: alpha=0.5555556, lambda=1000
- Fold06: alpha=0.5555556, lambda=1000
+ Fold06: alpha=0.6666667, lambda=1000
- Fold06: alpha=0.6666667, lambda=1000
+ Fold06: alpha=0.7777778, lambda=1000
- Fold06: alpha=0.7777778, lambda=1000
+ Fold06: alpha=0.8888889, lambda=1000
- Fold06: alpha=0.8888889, lambda=1000
+ Fold06: alpha=1.0000000, lambda=1000
- Fold06: alpha=1.0000000, lambda=1000
+ Fold07: alpha=0.0000000, lambda=1000
- Fold07: alpha=0.0000000, lambda=1000
+ Fold07: alpha=0.1111111, lambda=1000
- Fold07: alpha=0.1111111, lambda=1000
+ Fold07: alpha=0.2222222, lambda=1000
- Fold07: alpha=0.2222222, lambda=1000
+ Fold07: alpha=0.3333333, lambda=1000
- Fold07: alpha=0.3333333, lambda=1000
+ Fold07: alpha=0.4444444, lambda=1000
- Fold07: alpha=0.4444444, lambda=1000
+ Fold07: alpha=0.5555556, lambda=1000
- Fold07: alpha=0.5555556, lambda=1000
+ Fold07: alpha=0.6666667, lambda=1000
- Fold07: alpha=0.6666667, lambda=1000
+ Fold07: alpha=0.7777778, lambda=1000
- Fold07: alpha=0.7777778, lambda=1000
+ Fold07: alpha=0.8888889, lambda=1000
- Fold07: alpha=0.8888889, lambda=1000
+ Fold07: alpha=1.0000000, lambda=1000
- Fold07: alpha=1.0000000, lambda=1000
+ Fold08: alpha=0.0000000, lambda=1000
- Fold08: alpha=0.0000000, lambda=1000
+ Fold08: alpha=0.1111111, lambda=1000
- Fold08: alpha=0.1111111, lambda=1000
+ Fold08: alpha=0.2222222, lambda=1000
- Fold08: alpha=0.2222222, lambda=1000
+ Fold08: alpha=0.3333333, lambda=1000
- Fold08: alpha=0.3333333, lambda=1000
+ Fold08: alpha=0.4444444, lambda=1000
- Fold08: alpha=0.4444444, lambda=1000
+ Fold08: alpha=0.5555556, lambda=1000
- Fold08: alpha=0.5555556, lambda=1000
+ Fold08: alpha=0.6666667, lambda=1000
- Fold08: alpha=0.6666667, lambda=1000
+ Fold08: alpha=0.7777778, lambda=1000
- Fold08: alpha=0.7777778, lambda=1000
+ Fold08: alpha=0.8888889, lambda=1000
- Fold08: alpha=0.8888889, lambda=1000
+ Fold08: alpha=1.0000000, lambda=1000
- Fold08: alpha=1.0000000, lambda=1000
+ Fold09: alpha=0.0000000, lambda=1000
- Fold09: alpha=0.0000000, lambda=1000
+ Fold09: alpha=0.1111111, lambda=1000
- Fold09: alpha=0.1111111, lambda=1000
+ Fold09: alpha=0.2222222, lambda=1000
- Fold09: alpha=0.2222222, lambda=1000
+ Fold09: alpha=0.3333333, lambda=1000
- Fold09: alpha=0.3333333, lambda=1000
+ Fold09: alpha=0.4444444, lambda=1000
- Fold09: alpha=0.4444444, lambda=1000
+ Fold09: alpha=0.5555556, lambda=1000
- Fold09: alpha=0.5555556, lambda=1000
+ Fold09: alpha=0.6666667, lambda=1000
- Fold09: alpha=0.6666667, lambda=1000
+ Fold09: alpha=0.7777778, lambda=1000
- Fold09: alpha=0.7777778, lambda=1000
+ Fold09: alpha=0.8888889, lambda=1000
- Fold09: alpha=0.8888889, lambda=1000
+ Fold09: alpha=1.0000000, lambda=1000
- Fold09: alpha=1.0000000, lambda=1000
+ Fold10: alpha=0.0000000, lambda=1000
- Fold10: alpha=0.0000000, lambda=1000
+ Fold10: alpha=0.1111111, lambda=1000
- Fold10: alpha=0.1111111, lambda=1000
+ Fold10: alpha=0.2222222, lambda=1000
- Fold10: alpha=0.2222222, lambda=1000
+ Fold10: alpha=0.3333333, lambda=1000
- Fold10: alpha=0.3333333, lambda=1000
+ Fold10: alpha=0.4444444, lambda=1000
- Fold10: alpha=0.4444444, lambda=1000
+ Fold10: alpha=0.5555556, lambda=1000
- Fold10: alpha=0.5555556, lambda=1000
+ Fold10: alpha=0.6666667, lambda=1000
- Fold10: alpha=0.6666667, lambda=1000
+ Fold10: alpha=0.7777778, lambda=1000
- Fold10: alpha=0.7777778, lambda=1000
+ Fold10: alpha=0.8888889, lambda=1000
- Fold10: alpha=0.8888889, lambda=1000
+ Fold10: alpha=1.0000000, lambda=1000
- Fold10: alpha=1.0000000, lambda=1000
+ Fold11: alpha=0.0000000, lambda=1000
- Fold11: alpha=0.0000000, lambda=1000
+ Fold11: alpha=0.1111111, lambda=1000
- Fold11: alpha=0.1111111, lambda=1000
+ Fold11: alpha=0.2222222, lambda=1000
- Fold11: alpha=0.2222222, lambda=1000
+ Fold11: alpha=0.3333333, lambda=1000
- Fold11: alpha=0.3333333, lambda=1000
+ Fold11: alpha=0.4444444, lambda=1000
- Fold11: alpha=0.4444444, lambda=1000
+ Fold11: alpha=0.5555556, lambda=1000
- Fold11: alpha=0.5555556, lambda=1000
+ Fold11: alpha=0.6666667, lambda=1000
- Fold11: alpha=0.6666667, lambda=1000
+ Fold11: alpha=0.7777778, lambda=1000
- Fold11: alpha=0.7777778, lambda=1000
+ Fold11: alpha=0.8888889, lambda=1000
- Fold11: alpha=0.8888889, lambda=1000
+ Fold11: alpha=1.0000000, lambda=1000
- Fold11: alpha=1.0000000, lambda=1000
+ Fold12: alpha=0.0000000, lambda=1000
- Fold12: alpha=0.0000000, lambda=1000
+ Fold12: alpha=0.1111111, lambda=1000
- Fold12: alpha=0.1111111, lambda=1000
+ Fold12: alpha=0.2222222, lambda=1000
- Fold12: alpha=0.2222222, lambda=1000
+ Fold12: alpha=0.3333333, lambda=1000
- Fold12: alpha=0.3333333, lambda=1000
+ Fold12: alpha=0.4444444, lambda=1000
- Fold12: alpha=0.4444444, lambda=1000
+ Fold12: alpha=0.5555556, lambda=1000
- Fold12: alpha=0.5555556, lambda=1000
+ Fold12: alpha=0.6666667, lambda=1000
- Fold12: alpha=0.6666667, lambda=1000
+ Fold12: alpha=0.7777778, lambda=1000
- Fold12: alpha=0.7777778, lambda=1000
+ Fold12: alpha=0.8888889, lambda=1000
- Fold12: alpha=0.8888889, lambda=1000
+ Fold12: alpha=1.0000000, lambda=1000
- Fold12: alpha=1.0000000, lambda=1000
+ Fold13: alpha=0.0000000, lambda=1000
- Fold13: alpha=0.0000000, lambda=1000
+ Fold13: alpha=0.1111111, lambda=1000
- Fold13: alpha=0.1111111, lambda=1000
+ Fold13: alpha=0.2222222, lambda=1000
- Fold13: alpha=0.2222222, lambda=1000
+ Fold13: alpha=0.3333333, lambda=1000
- Fold13: alpha=0.3333333, lambda=1000
+ Fold13: alpha=0.4444444, lambda=1000
- Fold13: alpha=0.4444444, lambda=1000
+ Fold13: alpha=0.5555556, lambda=1000
- Fold13: alpha=0.5555556, lambda=1000
+ Fold13: alpha=0.6666667, lambda=1000
- Fold13: alpha=0.6666667, lambda=1000
+ Fold13: alpha=0.7777778, lambda=1000
- Fold13: alpha=0.7777778, lambda=1000
+ Fold13: alpha=0.8888889, lambda=1000
- Fold13: alpha=0.8888889, lambda=1000
+ Fold13: alpha=1.0000000, lambda=1000
- Fold13: alpha=1.0000000, lambda=1000
+ Fold14: alpha=0.0000000, lambda=1000
- Fold14: alpha=0.0000000, lambda=1000
+ Fold14: alpha=0.1111111, lambda=1000
- Fold14: alpha=0.1111111, lambda=1000
+ Fold14: alpha=0.2222222, lambda=1000
- Fold14: alpha=0.2222222, lambda=1000
+ Fold14: alpha=0.3333333, lambda=1000
- Fold14: alpha=0.3333333, lambda=1000
+ Fold14: alpha=0.4444444, lambda=1000
- Fold14: alpha=0.4444444, lambda=1000
+ Fold14: alpha=0.5555556, lambda=1000
- Fold14: alpha=0.5555556, lambda=1000
+ Fold14: alpha=0.6666667, lambda=1000
- Fold14: alpha=0.6666667, lambda=1000
+ Fold14: alpha=0.7777778, lambda=1000
- Fold14: alpha=0.7777778, lambda=1000
+ Fold14: alpha=0.8888889, lambda=1000
- Fold14: alpha=0.8888889, lambda=1000
+ Fold14: alpha=1.0000000, lambda=1000
- Fold14: alpha=1.0000000, lambda=1000
+ Fold15: alpha=0.0000000, lambda=1000
- Fold15: alpha=0.0000000, lambda=1000
+ Fold15: alpha=0.1111111, lambda=1000
- Fold15: alpha=0.1111111, lambda=1000
+ Fold15: alpha=0.2222222, lambda=1000
- Fold15: alpha=0.2222222, lambda=1000
+ Fold15: alpha=0.3333333, lambda=1000
- Fold15: alpha=0.3333333, lambda=1000
+ Fold15: alpha=0.4444444, lambda=1000
- Fold15: alpha=0.4444444, lambda=1000
+ Fold15: alpha=0.5555556, lambda=1000
- Fold15: alpha=0.5555556, lambda=1000
+ Fold15: alpha=0.6666667, lambda=1000
- Fold15: alpha=0.6666667, lambda=1000
+ Fold15: alpha=0.7777778, lambda=1000
- Fold15: alpha=0.7777778, lambda=1000
+ Fold15: alpha=0.8888889, lambda=1000
- Fold15: alpha=0.8888889, lambda=1000
+ Fold15: alpha=1.0000000, lambda=1000
- Fold15: alpha=1.0000000, lambda=1000
+ Fold16: alpha=0.0000000, lambda=1000
- Fold16: alpha=0.0000000, lambda=1000
+ Fold16: alpha=0.1111111, lambda=1000
- Fold16: alpha=0.1111111, lambda=1000
+ Fold16: alpha=0.2222222, lambda=1000
- Fold16: alpha=0.2222222, lambda=1000
+ Fold16: alpha=0.3333333, lambda=1000
- Fold16: alpha=0.3333333, lambda=1000
+ Fold16: alpha=0.4444444, lambda=1000
- Fold16: alpha=0.4444444, lambda=1000
+ Fold16: alpha=0.5555556, lambda=1000
- Fold16: alpha=0.5555556, lambda=1000
+ Fold16: alpha=0.6666667, lambda=1000
- Fold16: alpha=0.6666667, lambda=1000
+ Fold16: alpha=0.7777778, lambda=1000
- Fold16: alpha=0.7777778, lambda=1000
+ Fold16: alpha=0.8888889, lambda=1000
- Fold16: alpha=0.8888889, lambda=1000
+ Fold16: alpha=1.0000000, lambda=1000
- Fold16: alpha=1.0000000, lambda=1000
+ Fold17: alpha=0.0000000, lambda=1000
- Fold17: alpha=0.0000000, lambda=1000
+ Fold17: alpha=0.1111111, lambda=1000
- Fold17: alpha=0.1111111, lambda=1000
+ Fold17: alpha=0.2222222, lambda=1000
- Fold17: alpha=0.2222222, lambda=1000
+ Fold17: alpha=0.3333333, lambda=1000
- Fold17: alpha=0.3333333, lambda=1000
+ Fold17: alpha=0.4444444, lambda=1000
- Fold17: alpha=0.4444444, lambda=1000
+ Fold17: alpha=0.5555556, lambda=1000
- Fold17: alpha=0.5555556, lambda=1000
+ Fold17: alpha=0.6666667, lambda=1000
- Fold17: alpha=0.6666667, lambda=1000
+ Fold17: alpha=0.7777778, lambda=1000
- Fold17: alpha=0.7777778, lambda=1000
+ Fold17: alpha=0.8888889, lambda=1000
- Fold17: alpha=0.8888889, lambda=1000
+ Fold17: alpha=1.0000000, lambda=1000
- Fold17: alpha=1.0000000, lambda=1000
+ Fold18: alpha=0.0000000, lambda=1000
- Fold18: alpha=0.0000000, lambda=1000
+ Fold18: alpha=0.1111111, lambda=1000
- Fold18: alpha=0.1111111, lambda=1000
+ Fold18: alpha=0.2222222, lambda=1000
- Fold18: alpha=0.2222222, lambda=1000
+ Fold18: alpha=0.3333333, lambda=1000
- Fold18: alpha=0.3333333, lambda=1000
+ Fold18: alpha=0.4444444, lambda=1000
- Fold18: alpha=0.4444444, lambda=1000
+ Fold18: alpha=0.5555556, lambda=1000
- Fold18: alpha=0.5555556, lambda=1000
+ Fold18: alpha=0.6666667, lambda=1000
- Fold18: alpha=0.6666667, lambda=1000
+ Fold18: alpha=0.7777778, lambda=1000
- Fold18: alpha=0.7777778, lambda=1000
+ Fold18: alpha=0.8888889, lambda=1000
- Fold18: alpha=0.8888889, lambda=1000
+ Fold18: alpha=1.0000000, lambda=1000
- Fold18: alpha=1.0000000, lambda=1000
+ Fold19: alpha=0.0000000, lambda=1000
- Fold19: alpha=0.0000000, lambda=1000
+ Fold19: alpha=0.1111111, lambda=1000
- Fold19: alpha=0.1111111, lambda=1000
+ Fold19: alpha=0.2222222, lambda=1000
- Fold19: alpha=0.2222222, lambda=1000
+ Fold19: alpha=0.3333333, lambda=1000
- Fold19: alpha=0.3333333, lambda=1000
+ Fold19: alpha=0.4444444, lambda=1000
- Fold19: alpha=0.4444444, lambda=1000
+ Fold19: alpha=0.5555556, lambda=1000
- Fold19: alpha=0.5555556, lambda=1000
+ Fold19: alpha=0.6666667, lambda=1000
- Fold19: alpha=0.6666667, lambda=1000
+ Fold19: alpha=0.7777778, lambda=1000
- Fold19: alpha=0.7777778, lambda=1000
+ Fold19: alpha=0.8888889, lambda=1000
- Fold19: alpha=0.8888889, lambda=1000
+ Fold19: alpha=1.0000000, lambda=1000
- Fold19: alpha=1.0000000, lambda=1000
+ Fold20: alpha=0.0000000, lambda=1000
- Fold20: alpha=0.0000000, lambda=1000
+ Fold20: alpha=0.1111111, lambda=1000
- Fold20: alpha=0.1111111, lambda=1000
+ Fold20: alpha=0.2222222, lambda=1000
- Fold20: alpha=0.2222222, lambda=1000
+ Fold20: alpha=0.3333333, lambda=1000
- Fold20: alpha=0.3333333, lambda=1000
+ Fold20: alpha=0.4444444, lambda=1000
- Fold20: alpha=0.4444444, lambda=1000
+ Fold20: alpha=0.5555556, lambda=1000
- Fold20: alpha=0.5555556, lambda=1000
+ Fold20: alpha=0.6666667, lambda=1000
- Fold20: alpha=0.6666667, lambda=1000
+ Fold20: alpha=0.7777778, lambda=1000
- Fold20: alpha=0.7777778, lambda=1000
+ Fold20: alpha=0.8888889, lambda=1000
- Fold20: alpha=0.8888889, lambda=1000
+ Fold20: alpha=1.0000000, lambda=1000
- Fold20: alpha=1.0000000, lambda=1000
+ Fold21: alpha=0.0000000, lambda=1000
- Fold21: alpha=0.0000000, lambda=1000
+ Fold21: alpha=0.1111111, lambda=1000
- Fold21: alpha=0.1111111, lambda=1000
+ Fold21: alpha=0.2222222, lambda=1000
- Fold21: alpha=0.2222222, lambda=1000
+ Fold21: alpha=0.3333333, lambda=1000
- Fold21: alpha=0.3333333, lambda=1000
+ Fold21: alpha=0.4444444, lambda=1000
- Fold21: alpha=0.4444444, lambda=1000
+ Fold21: alpha=0.5555556, lambda=1000
- Fold21: alpha=0.5555556, lambda=1000
+ Fold21: alpha=0.6666667, lambda=1000
- Fold21: alpha=0.6666667, lambda=1000
+ Fold21: alpha=0.7777778, lambda=1000
- Fold21: alpha=0.7777778, lambda=1000
+ Fold21: alpha=0.8888889, lambda=1000
- Fold21: alpha=0.8888889, lambda=1000
+ Fold21: alpha=1.0000000, lambda=1000
- Fold21: alpha=1.0000000, lambda=1000
+ Fold22: alpha=0.0000000, lambda=1000
- Fold22: alpha=0.0000000, lambda=1000
+ Fold22: alpha=0.1111111, lambda=1000
- Fold22: alpha=0.1111111, lambda=1000
+ Fold22: alpha=0.2222222, lambda=1000
- Fold22: alpha=0.2222222, lambda=1000
+ Fold22: alpha=0.3333333, lambda=1000
- Fold22: alpha=0.3333333, lambda=1000
+ Fold22: alpha=0.4444444, lambda=1000
- Fold22: alpha=0.4444444, lambda=1000
+ Fold22: alpha=0.5555556, lambda=1000
- Fold22: alpha=0.5555556, lambda=1000
+ Fold22: alpha=0.6666667, lambda=1000
- Fold22: alpha=0.6666667, lambda=1000
+ Fold22: alpha=0.7777778, lambda=1000
- Fold22: alpha=0.7777778, lambda=1000
+ Fold22: alpha=0.8888889, lambda=1000
- Fold22: alpha=0.8888889, lambda=1000
+ Fold22: alpha=1.0000000, lambda=1000
- Fold22: alpha=1.0000000, lambda=1000
+ Fold23: alpha=0.0000000, lambda=1000
- Fold23: alpha=0.0000000, lambda=1000
+ Fold23: alpha=0.1111111, lambda=1000
- Fold23: alpha=0.1111111, lambda=1000
+ Fold23: alpha=0.2222222, lambda=1000
- Fold23: alpha=0.2222222, lambda=1000
+ Fold23: alpha=0.3333333, lambda=1000
- Fold23: alpha=0.3333333, lambda=1000
+ Fold23: alpha=0.4444444, lambda=1000
- Fold23: alpha=0.4444444, lambda=1000
+ Fold23: alpha=0.5555556, lambda=1000
- Fold23: alpha=0.5555556, lambda=1000
+ Fold23: alpha=0.6666667, lambda=1000
- Fold23: alpha=0.6666667, lambda=1000
+ Fold23: alpha=0.7777778, lambda=1000
- Fold23: alpha=0.7777778, lambda=1000
+ Fold23: alpha=0.8888889, lambda=1000
- Fold23: alpha=0.8888889, lambda=1000
+ Fold23: alpha=1.0000000, lambda=1000
- Fold23: alpha=1.0000000, lambda=1000
+ Fold24: alpha=0.0000000, lambda=1000
- Fold24: alpha=0.0000000, lambda=1000
+ Fold24: alpha=0.1111111, lambda=1000
- Fold24: alpha=0.1111111, lambda=1000
+ Fold24: alpha=0.2222222, lambda=1000
- Fold24: alpha=0.2222222, lambda=1000
+ Fold24: alpha=0.3333333, lambda=1000
- Fold24: alpha=0.3333333, lambda=1000
+ Fold24: alpha=0.4444444, lambda=1000
- Fold24: alpha=0.4444444, lambda=1000
+ Fold24: alpha=0.5555556, lambda=1000
- Fold24: alpha=0.5555556, lambda=1000
+ Fold24: alpha=0.6666667, lambda=1000
- Fold24: alpha=0.6666667, lambda=1000
+ Fold24: alpha=0.7777778, lambda=1000
- Fold24: alpha=0.7777778, lambda=1000
+ Fold24: alpha=0.8888889, lambda=1000
- Fold24: alpha=0.8888889, lambda=1000
+ Fold24: alpha=1.0000000, lambda=1000
- Fold24: alpha=1.0000000, lambda=1000
+ Fold25: alpha=0.0000000, lambda=1000
- Fold25: alpha=0.0000000, lambda=1000
+ Fold25: alpha=0.1111111, lambda=1000
- Fold25: alpha=0.1111111, lambda=1000
+ Fold25: alpha=0.2222222, lambda=1000
- Fold25: alpha=0.2222222, lambda=1000
+ Fold25: alpha=0.3333333, lambda=1000
- Fold25: alpha=0.3333333, lambda=1000
+ Fold25: alpha=0.4444444, lambda=1000
- Fold25: alpha=0.4444444, lambda=1000
+ Fold25: alpha=0.5555556, lambda=1000
- Fold25: alpha=0.5555556, lambda=1000
+ Fold25: alpha=0.6666667, lambda=1000
- Fold25: alpha=0.6666667, lambda=1000
+ Fold25: alpha=0.7777778, lambda=1000
- Fold25: alpha=0.7777778, lambda=1000
+ Fold25: alpha=0.8888889, lambda=1000
- Fold25: alpha=0.8888889, lambda=1000
+ Fold25: alpha=1.0000000, lambda=1000
- Fold25: alpha=1.0000000, lambda=1000
+ Fold26: alpha=0.0000000, lambda=1000
- Fold26: alpha=0.0000000, lambda=1000
+ Fold26: alpha=0.1111111, lambda=1000
- Fold26: alpha=0.1111111, lambda=1000
+ Fold26: alpha=0.2222222, lambda=1000
- Fold26: alpha=0.2222222, lambda=1000
+ Fold26: alpha=0.3333333, lambda=1000
- Fold26: alpha=0.3333333, lambda=1000
+ Fold26: alpha=0.4444444, lambda=1000
- Fold26: alpha=0.4444444, lambda=1000
+ Fold26: alpha=0.5555556, lambda=1000
- Fold26: alpha=0.5555556, lambda=1000
+ Fold26: alpha=0.6666667, lambda=1000
- Fold26: alpha=0.6666667, lambda=1000
+ Fold26: alpha=0.7777778, lambda=1000
- Fold26: alpha=0.7777778, lambda=1000
+ Fold26: alpha=0.8888889, lambda=1000
- Fold26: alpha=0.8888889, lambda=1000
+ Fold26: alpha=1.0000000, lambda=1000
- Fold26: alpha=1.0000000, lambda=1000
+ Fold27: alpha=0.0000000, lambda=1000
- Fold27: alpha=0.0000000, lambda=1000
+ Fold27: alpha=0.1111111, lambda=1000
- Fold27: alpha=0.1111111, lambda=1000
+ Fold27: alpha=0.2222222, lambda=1000
- Fold27: alpha=0.2222222, lambda=1000
+ Fold27: alpha=0.3333333, lambda=1000
- Fold27: alpha=0.3333333, lambda=1000
+ Fold27: alpha=0.4444444, lambda=1000
- Fold27: alpha=0.4444444, lambda=1000
+ Fold27: alpha=0.5555556, lambda=1000
- Fold27: alpha=0.5555556, lambda=1000
+ Fold27: alpha=0.6666667, lambda=1000
- Fold27: alpha=0.6666667, lambda=1000
+ Fold27: alpha=0.7777778, lambda=1000
- Fold27: alpha=0.7777778, lambda=1000
+ Fold27: alpha=0.8888889, lambda=1000
- Fold27: alpha=0.8888889, lambda=1000
+ Fold27: alpha=1.0000000, lambda=1000
- Fold27: alpha=1.0000000, lambda=1000
+ Fold28: alpha=0.0000000, lambda=1000
- Fold28: alpha=0.0000000, lambda=1000
+ Fold28: alpha=0.1111111, lambda=1000
- Fold28: alpha=0.1111111, lambda=1000
+ Fold28: alpha=0.2222222, lambda=1000
- Fold28: alpha=0.2222222, lambda=1000
+ Fold28: alpha=0.3333333, lambda=1000
- Fold28: alpha=0.3333333, lambda=1000
+ Fold28: alpha=0.4444444, lambda=1000
- Fold28: alpha=0.4444444, lambda=1000
+ Fold28: alpha=0.5555556, lambda=1000
- Fold28: alpha=0.5555556, lambda=1000
+ Fold28: alpha=0.6666667, lambda=1000
- Fold28: alpha=0.6666667, lambda=1000
+ Fold28: alpha=0.7777778, lambda=1000
- Fold28: alpha=0.7777778, lambda=1000
+ Fold28: alpha=0.8888889, lambda=1000
- Fold28: alpha=0.8888889, lambda=1000
+ Fold28: alpha=1.0000000, lambda=1000
- Fold28: alpha=1.0000000, lambda=1000
Aggregating results
Selecting tuning parameters
Fitting alpha = 0.778, lambda = 0.0215 on full training set# Display the best alpha and lambda values
print(elastic_net_model$bestTune) alpha lambda
723 0.7777778 0.02154435# Plot the results to see the optimal alpha and lambda
plot(elastic_net_model)
# Make predictions on the dataset
predictions <- predict(elastic_net_model, newdata = data_models)
# Evaluate model performance
mse <- mean((predictions - data_models$mean_trans_docs)^2)
r_squared <- 1 - sum((predictions - data_models$mean_trans_docs)^2) / sum((data_models$mean_trans_docs - mean(data_models$mean_trans_docs))^2)
# Print evaluation metrics
print(paste("MSE:", mse))[1] "MSE: 0.00227648789058555"[1] "R-squared: 0.946905167042649"# # Calculate predictions and residuals
# predictions <- predict(lasso_model, data_models)
# # Extract the actual values
# actual <- data_models$mean_trans_docs
# # Calculate residuals
# residuals <- actual - predictions
#
#
# # Calculate R-squared and RMSE
# r_squared <- 1 - sum(residuals^2) / sum((actual - mean(actual))^2)
# rmse <- sqrt(mean(residuals^2))
#
#
# cat("R-squared:", r_squared, "\n")
# cat("RMSE:", rmse, "\n")
#
# # Plot actual vs predicted values
# plot(actual, predictions,
# main = "Actual vs Predicted Values",
# xlab = "Actual", ylab = "Predicted",
# pch = 16, col = "blue")
# abline(0, 1, col = "red")
#
# # Plot residuals
# plot(predictions, residuals,
# main = "Residuals vs Predicted Values",
# xlab = "Predicted Values", ylab = "Residuals",
# pch = 16, col = "blue")
# abline(h = 0, col = "red")
#
# # Combine country names with predictions
# country_predictions <- data.frame(
# country = data_aggr$country,
# actual = target,
# predicted = predictions
# )
#
# # Sort by prediction (descending)
# country_predictions <- country_predictions[order(country_predictions$predicted, decreasing = TRUE), ]
# print(country_predictions)Random forest
# I CHANGED THE DATA USED TO DATA_MODELS SO I COULD KEEP THE COUNTRY COLUMN FOR PREDICTIONS
# data_aggr <- data_aggr |>
# select(-country)
# Define LOOCV control
control <- trainControl(
method = "LOOCV",
verboseIter = TRUE, # Print progress
returnResamp = "all" # Save all resampling results
)
# Define hyperparameter grid for Random Forest
rf_grid <- expand.grid(
mtry = seq(2, ncol(data_models) - 1, by = 2)
)
# mtry the number of variables randomly sampled at each split
# Train Random Forest model with hyperparameter tuning
rf_model <- train(
mean_trans_docs ~ .,
data = data_models,
method = "rf",
preProc=c('scale','center'),
trControl = control,
tuneGrid = rf_grid,
importance = TRUE # Calculate variable importance
)+ Fold01: mtry= 2
- Fold01: mtry= 2
+ Fold01: mtry= 4
- Fold01: mtry= 4
+ Fold01: mtry= 6
- Fold01: mtry= 6
+ Fold01: mtry= 8
- Fold01: mtry= 8
+ Fold01: mtry=10
- Fold01: mtry=10
+ Fold01: mtry=12
- Fold01: mtry=12
+ Fold01: mtry=14
- Fold01: mtry=14
+ Fold01: mtry=16
- Fold01: mtry=16
+ Fold01: mtry=18
- Fold01: mtry=18
+ Fold01: mtry=20
- Fold01: mtry=20
+ Fold01: mtry=22
- Fold01: mtry=22
+ Fold01: mtry=24
- Fold01: mtry=24
+ Fold01: mtry=26
- Fold01: mtry=26
+ Fold01: mtry=28
- Fold01: mtry=28
+ Fold01: mtry=30
- Fold01: mtry=30
+ Fold01: mtry=32
- Fold01: mtry=32
+ Fold01: mtry=34
- Fold01: mtry=34
+ Fold01: mtry=36
- Fold01: mtry=36
+ Fold01: mtry=38
- Fold01: mtry=38
+ Fold01: mtry=40
- Fold01: mtry=40
+ Fold01: mtry=42
- Fold01: mtry=42
+ Fold01: mtry=44
- Fold01: mtry=44
+ Fold01: mtry=46
- Fold01: mtry=46
+ Fold01: mtry=48
- Fold01: mtry=48
+ Fold01: mtry=50
- Fold01: mtry=50
+ Fold01: mtry=52
- Fold01: mtry=52
+ Fold01: mtry=54
- Fold01: mtry=54
+ Fold01: mtry=56
- Fold01: mtry=56
+ Fold01: mtry=58
- Fold01: mtry=58
+ Fold01: mtry=60
- Fold01: mtry=60
+ Fold01: mtry=62
- Fold01: mtry=62
+ Fold01: mtry=64
- Fold01: mtry=64
+ Fold01: mtry=66
- Fold01: mtry=66
+ Fold01: mtry=68
- Fold01: mtry=68
+ Fold01: mtry=70
- Fold01: mtry=70
+ Fold01: mtry=72
- Fold01: mtry=72
+ Fold01: mtry=74
- Fold01: mtry=74
+ Fold01: mtry=76
- Fold01: mtry=76
+ Fold02: mtry= 2
- Fold02: mtry= 2
+ Fold02: mtry= 4
- Fold02: mtry= 4
+ Fold02: mtry= 6
- Fold02: mtry= 6
+ Fold02: mtry= 8
- Fold02: mtry= 8
+ Fold02: mtry=10
- Fold02: mtry=10
+ Fold02: mtry=12
- Fold02: mtry=12
+ Fold02: mtry=14
- Fold02: mtry=14
+ Fold02: mtry=16
- Fold02: mtry=16
+ Fold02: mtry=18
- Fold02: mtry=18
+ Fold02: mtry=20
- Fold02: mtry=20
+ Fold02: mtry=22
- Fold02: mtry=22
+ Fold02: mtry=24
- Fold02: mtry=24
+ Fold02: mtry=26
- Fold02: mtry=26
+ Fold02: mtry=28
- Fold02: mtry=28
+ Fold02: mtry=30
- Fold02: mtry=30
+ Fold02: mtry=32
- Fold02: mtry=32
+ Fold02: mtry=34
- Fold02: mtry=34
+ Fold02: mtry=36
- Fold02: mtry=36
+ Fold02: mtry=38
- Fold02: mtry=38
+ Fold02: mtry=40
- Fold02: mtry=40
+ Fold02: mtry=42
- Fold02: mtry=42
+ Fold02: mtry=44
- Fold02: mtry=44
+ Fold02: mtry=46
- Fold02: mtry=46
+ Fold02: mtry=48
- Fold02: mtry=48
+ Fold02: mtry=50
- Fold02: mtry=50
+ Fold02: mtry=52
- Fold02: mtry=52
+ Fold02: mtry=54
- Fold02: mtry=54
+ Fold02: mtry=56
- Fold02: mtry=56
+ Fold02: mtry=58
- Fold02: mtry=58
+ Fold02: mtry=60
- Fold02: mtry=60
+ Fold02: mtry=62
- Fold02: mtry=62
+ Fold02: mtry=64
- Fold02: mtry=64
+ Fold02: mtry=66
- Fold02: mtry=66
+ Fold02: mtry=68
- Fold02: mtry=68
+ Fold02: mtry=70
- Fold02: mtry=70
+ Fold02: mtry=72
- Fold02: mtry=72
+ Fold02: mtry=74
- Fold02: mtry=74
+ Fold02: mtry=76
- Fold02: mtry=76
+ Fold03: mtry= 2
- Fold03: mtry= 2
+ Fold03: mtry= 4
- Fold03: mtry= 4
+ Fold03: mtry= 6
- Fold03: mtry= 6
+ Fold03: mtry= 8
- Fold03: mtry= 8
+ Fold03: mtry=10
- Fold03: mtry=10
+ Fold03: mtry=12
- Fold03: mtry=12
+ Fold03: mtry=14
- Fold03: mtry=14
+ Fold03: mtry=16
- Fold03: mtry=16
+ Fold03: mtry=18
- Fold03: mtry=18
+ Fold03: mtry=20
- Fold03: mtry=20
+ Fold03: mtry=22
- Fold03: mtry=22
+ Fold03: mtry=24
- Fold03: mtry=24
+ Fold03: mtry=26
- Fold03: mtry=26
+ Fold03: mtry=28
- Fold03: mtry=28
+ Fold03: mtry=30
- Fold03: mtry=30
+ Fold03: mtry=32
- Fold03: mtry=32
+ Fold03: mtry=34
- Fold03: mtry=34
+ Fold03: mtry=36
- Fold03: mtry=36
+ Fold03: mtry=38
- Fold03: mtry=38
+ Fold03: mtry=40
- Fold03: mtry=40
+ Fold03: mtry=42
- Fold03: mtry=42
+ Fold03: mtry=44
- Fold03: mtry=44
+ Fold03: mtry=46
- Fold03: mtry=46
+ Fold03: mtry=48
- Fold03: mtry=48
+ Fold03: mtry=50
- Fold03: mtry=50
+ Fold03: mtry=52
- Fold03: mtry=52
+ Fold03: mtry=54
- Fold03: mtry=54
+ Fold03: mtry=56
- Fold03: mtry=56
+ Fold03: mtry=58
- Fold03: mtry=58
+ Fold03: mtry=60
- Fold03: mtry=60
+ Fold03: mtry=62
- Fold03: mtry=62
+ Fold03: mtry=64
- Fold03: mtry=64
+ Fold03: mtry=66
- Fold03: mtry=66
+ Fold03: mtry=68
- Fold03: mtry=68
+ Fold03: mtry=70
- Fold03: mtry=70
+ Fold03: mtry=72
- Fold03: mtry=72
+ Fold03: mtry=74
- Fold03: mtry=74
+ Fold03: mtry=76
- Fold03: mtry=76
+ Fold04: mtry= 2
- Fold04: mtry= 2
+ Fold04: mtry= 4
- Fold04: mtry= 4
+ Fold04: mtry= 6
- Fold04: mtry= 6
+ Fold04: mtry= 8
- Fold04: mtry= 8
+ Fold04: mtry=10
- Fold04: mtry=10
+ Fold04: mtry=12
- Fold04: mtry=12
+ Fold04: mtry=14
- Fold04: mtry=14
+ Fold04: mtry=16
- Fold04: mtry=16
+ Fold04: mtry=18
- Fold04: mtry=18
+ Fold04: mtry=20
- Fold04: mtry=20
+ Fold04: mtry=22
- Fold04: mtry=22
+ Fold04: mtry=24
- Fold04: mtry=24
+ Fold04: mtry=26
- Fold04: mtry=26
+ Fold04: mtry=28
- Fold04: mtry=28
+ Fold04: mtry=30
- Fold04: mtry=30
+ Fold04: mtry=32
- Fold04: mtry=32
+ Fold04: mtry=34
- Fold04: mtry=34
+ Fold04: mtry=36
- Fold04: mtry=36
+ Fold04: mtry=38
- Fold04: mtry=38
+ Fold04: mtry=40
- Fold04: mtry=40
+ Fold04: mtry=42
- Fold04: mtry=42
+ Fold04: mtry=44
- Fold04: mtry=44
+ Fold04: mtry=46
- Fold04: mtry=46
+ Fold04: mtry=48
- Fold04: mtry=48
+ Fold04: mtry=50
- Fold04: mtry=50
+ Fold04: mtry=52
- Fold04: mtry=52
+ Fold04: mtry=54
- Fold04: mtry=54
+ Fold04: mtry=56
- Fold04: mtry=56
+ Fold04: mtry=58
- Fold04: mtry=58
+ Fold04: mtry=60
- Fold04: mtry=60
+ Fold04: mtry=62
- Fold04: mtry=62
+ Fold04: mtry=64
- Fold04: mtry=64
+ Fold04: mtry=66
- Fold04: mtry=66
+ Fold04: mtry=68
- Fold04: mtry=68
+ Fold04: mtry=70
- Fold04: mtry=70
+ Fold04: mtry=72
- Fold04: mtry=72
+ Fold04: mtry=74
- Fold04: mtry=74
+ Fold04: mtry=76
- Fold04: mtry=76
+ Fold05: mtry= 2
- Fold05: mtry= 2
+ Fold05: mtry= 4
- Fold05: mtry= 4
+ Fold05: mtry= 6
- Fold05: mtry= 6
+ Fold05: mtry= 8
- Fold05: mtry= 8
+ Fold05: mtry=10
- Fold05: mtry=10
+ Fold05: mtry=12
- Fold05: mtry=12
+ Fold05: mtry=14
- Fold05: mtry=14
+ Fold05: mtry=16
- Fold05: mtry=16
+ Fold05: mtry=18
- Fold05: mtry=18
+ Fold05: mtry=20
- Fold05: mtry=20
+ Fold05: mtry=22
- Fold05: mtry=22
+ Fold05: mtry=24
- Fold05: mtry=24
+ Fold05: mtry=26
- Fold05: mtry=26
+ Fold05: mtry=28
- Fold05: mtry=28
+ Fold05: mtry=30
- Fold05: mtry=30
+ Fold05: mtry=32
- Fold05: mtry=32
+ Fold05: mtry=34
- Fold05: mtry=34
+ Fold05: mtry=36
- Fold05: mtry=36
+ Fold05: mtry=38
- Fold05: mtry=38
+ Fold05: mtry=40
- Fold05: mtry=40
+ Fold05: mtry=42
- Fold05: mtry=42
+ Fold05: mtry=44
- Fold05: mtry=44
+ Fold05: mtry=46
- Fold05: mtry=46
+ Fold05: mtry=48
- Fold05: mtry=48
+ Fold05: mtry=50
- Fold05: mtry=50
+ Fold05: mtry=52
- Fold05: mtry=52
+ Fold05: mtry=54
- Fold05: mtry=54
+ Fold05: mtry=56
- Fold05: mtry=56
+ Fold05: mtry=58
- Fold05: mtry=58
+ Fold05: mtry=60
- Fold05: mtry=60
+ Fold05: mtry=62
- Fold05: mtry=62
+ Fold05: mtry=64
- Fold05: mtry=64
+ Fold05: mtry=66
- Fold05: mtry=66
+ Fold05: mtry=68
- Fold05: mtry=68
+ Fold05: mtry=70
- Fold05: mtry=70
+ Fold05: mtry=72
- Fold05: mtry=72
+ Fold05: mtry=74
- Fold05: mtry=74
+ Fold05: mtry=76
- Fold05: mtry=76
+ Fold06: mtry= 2
- Fold06: mtry= 2
+ Fold06: mtry= 4
- Fold06: mtry= 4
+ Fold06: mtry= 6
- Fold06: mtry= 6
+ Fold06: mtry= 8
- Fold06: mtry= 8
+ Fold06: mtry=10
- Fold06: mtry=10
+ Fold06: mtry=12
- Fold06: mtry=12
+ Fold06: mtry=14
- Fold06: mtry=14
+ Fold06: mtry=16
- Fold06: mtry=16
+ Fold06: mtry=18
- Fold06: mtry=18
+ Fold06: mtry=20
- Fold06: mtry=20
+ Fold06: mtry=22
- Fold06: mtry=22
+ Fold06: mtry=24
- Fold06: mtry=24
+ Fold06: mtry=26
- Fold06: mtry=26
+ Fold06: mtry=28
- Fold06: mtry=28
+ Fold06: mtry=30
- Fold06: mtry=30
+ Fold06: mtry=32
- Fold06: mtry=32
+ Fold06: mtry=34
- Fold06: mtry=34
+ Fold06: mtry=36
- Fold06: mtry=36
+ Fold06: mtry=38
- Fold06: mtry=38
+ Fold06: mtry=40
- Fold06: mtry=40
+ Fold06: mtry=42
- Fold06: mtry=42
+ Fold06: mtry=44
- Fold06: mtry=44
+ Fold06: mtry=46
- Fold06: mtry=46
+ Fold06: mtry=48
- Fold06: mtry=48
+ Fold06: mtry=50
- Fold06: mtry=50
+ Fold06: mtry=52
- Fold06: mtry=52
+ Fold06: mtry=54
- Fold06: mtry=54
+ Fold06: mtry=56
- Fold06: mtry=56
+ Fold06: mtry=58
- Fold06: mtry=58
+ Fold06: mtry=60
- Fold06: mtry=60
+ Fold06: mtry=62
- Fold06: mtry=62
+ Fold06: mtry=64
- Fold06: mtry=64
+ Fold06: mtry=66
- Fold06: mtry=66
+ Fold06: mtry=68
- Fold06: mtry=68
+ Fold06: mtry=70
- Fold06: mtry=70
+ Fold06: mtry=72
- Fold06: mtry=72
+ Fold06: mtry=74
- Fold06: mtry=74
+ Fold06: mtry=76
- Fold06: mtry=76
+ Fold07: mtry= 2
- Fold07: mtry= 2
+ Fold07: mtry= 4
- Fold07: mtry= 4
+ Fold07: mtry= 6
- Fold07: mtry= 6
+ Fold07: mtry= 8
- Fold07: mtry= 8
+ Fold07: mtry=10
- Fold07: mtry=10
+ Fold07: mtry=12
- Fold07: mtry=12
+ Fold07: mtry=14
- Fold07: mtry=14
+ Fold07: mtry=16
- Fold07: mtry=16
+ Fold07: mtry=18
- Fold07: mtry=18
+ Fold07: mtry=20
- Fold07: mtry=20
+ Fold07: mtry=22
- Fold07: mtry=22
+ Fold07: mtry=24
- Fold07: mtry=24
+ Fold07: mtry=26
- Fold07: mtry=26
+ Fold07: mtry=28
- Fold07: mtry=28
+ Fold07: mtry=30
- Fold07: mtry=30
+ Fold07: mtry=32
- Fold07: mtry=32
+ Fold07: mtry=34
- Fold07: mtry=34
+ Fold07: mtry=36
- Fold07: mtry=36
+ Fold07: mtry=38
- Fold07: mtry=38
+ Fold07: mtry=40
- Fold07: mtry=40
+ Fold07: mtry=42
- Fold07: mtry=42
+ Fold07: mtry=44
- Fold07: mtry=44
+ Fold07: mtry=46
- Fold07: mtry=46
+ Fold07: mtry=48
- Fold07: mtry=48
+ Fold07: mtry=50
- Fold07: mtry=50
+ Fold07: mtry=52
- Fold07: mtry=52
+ Fold07: mtry=54
- Fold07: mtry=54
+ Fold07: mtry=56
- Fold07: mtry=56
+ Fold07: mtry=58
- Fold07: mtry=58
+ Fold07: mtry=60
- Fold07: mtry=60
+ Fold07: mtry=62
- Fold07: mtry=62
+ Fold07: mtry=64
- Fold07: mtry=64
+ Fold07: mtry=66
- Fold07: mtry=66
+ Fold07: mtry=68
- Fold07: mtry=68
+ Fold07: mtry=70
- Fold07: mtry=70
+ Fold07: mtry=72
- Fold07: mtry=72
+ Fold07: mtry=74
- Fold07: mtry=74
+ Fold07: mtry=76
- Fold07: mtry=76
+ Fold08: mtry= 2
- Fold08: mtry= 2
+ Fold08: mtry= 4
- Fold08: mtry= 4
+ Fold08: mtry= 6
- Fold08: mtry= 6
+ Fold08: mtry= 8
- Fold08: mtry= 8
+ Fold08: mtry=10
- Fold08: mtry=10
+ Fold08: mtry=12
- Fold08: mtry=12
+ Fold08: mtry=14
- Fold08: mtry=14
+ Fold08: mtry=16
- Fold08: mtry=16
+ Fold08: mtry=18
- Fold08: mtry=18
+ Fold08: mtry=20
- Fold08: mtry=20
+ Fold08: mtry=22
- Fold08: mtry=22
+ Fold08: mtry=24
- Fold08: mtry=24
+ Fold08: mtry=26
- Fold08: mtry=26
+ Fold08: mtry=28
- Fold08: mtry=28
+ Fold08: mtry=30
- Fold08: mtry=30
+ Fold08: mtry=32
- Fold08: mtry=32
+ Fold08: mtry=34
- Fold08: mtry=34
+ Fold08: mtry=36
- Fold08: mtry=36
+ Fold08: mtry=38
- Fold08: mtry=38
+ Fold08: mtry=40
- Fold08: mtry=40
+ Fold08: mtry=42
- Fold08: mtry=42
+ Fold08: mtry=44
- Fold08: mtry=44
+ Fold08: mtry=46
- Fold08: mtry=46
+ Fold08: mtry=48
- Fold08: mtry=48
+ Fold08: mtry=50
- Fold08: mtry=50
+ Fold08: mtry=52
- Fold08: mtry=52
+ Fold08: mtry=54
- Fold08: mtry=54
+ Fold08: mtry=56
- Fold08: mtry=56
+ Fold08: mtry=58
- Fold08: mtry=58
+ Fold08: mtry=60
- Fold08: mtry=60
+ Fold08: mtry=62
- Fold08: mtry=62
+ Fold08: mtry=64
- Fold08: mtry=64
+ Fold08: mtry=66
- Fold08: mtry=66
+ Fold08: mtry=68
- Fold08: mtry=68
+ Fold08: mtry=70
- Fold08: mtry=70
+ Fold08: mtry=72
- Fold08: mtry=72
+ Fold08: mtry=74
- Fold08: mtry=74
+ Fold08: mtry=76
- Fold08: mtry=76
+ Fold09: mtry= 2
- Fold09: mtry= 2
+ Fold09: mtry= 4
- Fold09: mtry= 4
+ Fold09: mtry= 6
- Fold09: mtry= 6
+ Fold09: mtry= 8
- Fold09: mtry= 8
+ Fold09: mtry=10
- Fold09: mtry=10
+ Fold09: mtry=12
- Fold09: mtry=12
+ Fold09: mtry=14
- Fold09: mtry=14
+ Fold09: mtry=16
- Fold09: mtry=16
+ Fold09: mtry=18
- Fold09: mtry=18
+ Fold09: mtry=20
- Fold09: mtry=20
+ Fold09: mtry=22
- Fold09: mtry=22
+ Fold09: mtry=24
- Fold09: mtry=24
+ Fold09: mtry=26
- Fold09: mtry=26
+ Fold09: mtry=28
- Fold09: mtry=28
+ Fold09: mtry=30
- Fold09: mtry=30
+ Fold09: mtry=32
- Fold09: mtry=32
+ Fold09: mtry=34
- Fold09: mtry=34
+ Fold09: mtry=36
- Fold09: mtry=36
+ Fold09: mtry=38
- Fold09: mtry=38
+ Fold09: mtry=40
- Fold09: mtry=40
+ Fold09: mtry=42
- Fold09: mtry=42
+ Fold09: mtry=44
- Fold09: mtry=44
+ Fold09: mtry=46
- Fold09: mtry=46
+ Fold09: mtry=48
- Fold09: mtry=48
+ Fold09: mtry=50
- Fold09: mtry=50
+ Fold09: mtry=52
- Fold09: mtry=52
+ Fold09: mtry=54
- Fold09: mtry=54
+ Fold09: mtry=56
- Fold09: mtry=56
+ Fold09: mtry=58
- Fold09: mtry=58
+ Fold09: mtry=60
- Fold09: mtry=60
+ Fold09: mtry=62
- Fold09: mtry=62
+ Fold09: mtry=64
- Fold09: mtry=64
+ Fold09: mtry=66
- Fold09: mtry=66
+ Fold09: mtry=68
- Fold09: mtry=68
+ Fold09: mtry=70
- Fold09: mtry=70
+ Fold09: mtry=72
- Fold09: mtry=72
+ Fold09: mtry=74
- Fold09: mtry=74
+ Fold09: mtry=76
- Fold09: mtry=76
+ Fold10: mtry= 2
- Fold10: mtry= 2
+ Fold10: mtry= 4
- Fold10: mtry= 4
+ Fold10: mtry= 6
- Fold10: mtry= 6
+ Fold10: mtry= 8
- Fold10: mtry= 8
+ Fold10: mtry=10
- Fold10: mtry=10
+ Fold10: mtry=12
- Fold10: mtry=12
+ Fold10: mtry=14
- Fold10: mtry=14
+ Fold10: mtry=16
- Fold10: mtry=16
+ Fold10: mtry=18
- Fold10: mtry=18
+ Fold10: mtry=20
- Fold10: mtry=20
+ Fold10: mtry=22
- Fold10: mtry=22
+ Fold10: mtry=24
- Fold10: mtry=24
+ Fold10: mtry=26
- Fold10: mtry=26
+ Fold10: mtry=28
- Fold10: mtry=28
+ Fold10: mtry=30
- Fold10: mtry=30
+ Fold10: mtry=32
- Fold10: mtry=32
+ Fold10: mtry=34
- Fold10: mtry=34
+ Fold10: mtry=36
- Fold10: mtry=36
+ Fold10: mtry=38
- Fold10: mtry=38
+ Fold10: mtry=40
- Fold10: mtry=40
+ Fold10: mtry=42
- Fold10: mtry=42
+ Fold10: mtry=44
- Fold10: mtry=44
+ Fold10: mtry=46
- Fold10: mtry=46
+ Fold10: mtry=48
- Fold10: mtry=48
+ Fold10: mtry=50
- Fold10: mtry=50
+ Fold10: mtry=52
- Fold10: mtry=52
+ Fold10: mtry=54
- Fold10: mtry=54
+ Fold10: mtry=56
- Fold10: mtry=56
+ Fold10: mtry=58
- Fold10: mtry=58
+ Fold10: mtry=60
- Fold10: mtry=60
+ Fold10: mtry=62
- Fold10: mtry=62
+ Fold10: mtry=64
- Fold10: mtry=64
+ Fold10: mtry=66
- Fold10: mtry=66
+ Fold10: mtry=68
- Fold10: mtry=68
+ Fold10: mtry=70
- Fold10: mtry=70
+ Fold10: mtry=72
- Fold10: mtry=72
+ Fold10: mtry=74
- Fold10: mtry=74
+ Fold10: mtry=76
- Fold10: mtry=76
+ Fold11: mtry= 2
- Fold11: mtry= 2
+ Fold11: mtry= 4
- Fold11: mtry= 4
+ Fold11: mtry= 6
- Fold11: mtry= 6
+ Fold11: mtry= 8
- Fold11: mtry= 8
+ Fold11: mtry=10
- Fold11: mtry=10
+ Fold11: mtry=12
- Fold11: mtry=12
+ Fold11: mtry=14
- Fold11: mtry=14
+ Fold11: mtry=16
- Fold11: mtry=16
+ Fold11: mtry=18
- Fold11: mtry=18
+ Fold11: mtry=20
- Fold11: mtry=20
+ Fold11: mtry=22
- Fold11: mtry=22
+ Fold11: mtry=24
- Fold11: mtry=24
+ Fold11: mtry=26
- Fold11: mtry=26
+ Fold11: mtry=28
- Fold11: mtry=28
+ Fold11: mtry=30
- Fold11: mtry=30
+ Fold11: mtry=32
- Fold11: mtry=32
+ Fold11: mtry=34
- Fold11: mtry=34
+ Fold11: mtry=36
- Fold11: mtry=36
+ Fold11: mtry=38
- Fold11: mtry=38
+ Fold11: mtry=40
- Fold11: mtry=40
+ Fold11: mtry=42
- Fold11: mtry=42
+ Fold11: mtry=44
- Fold11: mtry=44
+ Fold11: mtry=46
- Fold11: mtry=46
+ Fold11: mtry=48
- Fold11: mtry=48
+ Fold11: mtry=50
- Fold11: mtry=50
+ Fold11: mtry=52
- Fold11: mtry=52
+ Fold11: mtry=54
- Fold11: mtry=54
+ Fold11: mtry=56
- Fold11: mtry=56
+ Fold11: mtry=58
- Fold11: mtry=58
+ Fold11: mtry=60
- Fold11: mtry=60
+ Fold11: mtry=62
- Fold11: mtry=62
+ Fold11: mtry=64
- Fold11: mtry=64
+ Fold11: mtry=66
- Fold11: mtry=66
+ Fold11: mtry=68
- Fold11: mtry=68
+ Fold11: mtry=70
- Fold11: mtry=70
+ Fold11: mtry=72
- Fold11: mtry=72
+ Fold11: mtry=74
- Fold11: mtry=74
+ Fold11: mtry=76
- Fold11: mtry=76
+ Fold12: mtry= 2
- Fold12: mtry= 2
+ Fold12: mtry= 4
- Fold12: mtry= 4
+ Fold12: mtry= 6
- Fold12: mtry= 6
+ Fold12: mtry= 8
- Fold12: mtry= 8
+ Fold12: mtry=10
- Fold12: mtry=10
+ Fold12: mtry=12
- Fold12: mtry=12
+ Fold12: mtry=14
- Fold12: mtry=14
+ Fold12: mtry=16
- Fold12: mtry=16
+ Fold12: mtry=18
- Fold12: mtry=18
+ Fold12: mtry=20
- Fold12: mtry=20
+ Fold12: mtry=22
- Fold12: mtry=22
+ Fold12: mtry=24
- Fold12: mtry=24
+ Fold12: mtry=26
- Fold12: mtry=26
+ Fold12: mtry=28
- Fold12: mtry=28
+ Fold12: mtry=30
- Fold12: mtry=30
+ Fold12: mtry=32
- Fold12: mtry=32
+ Fold12: mtry=34
- Fold12: mtry=34
+ Fold12: mtry=36
- Fold12: mtry=36
+ Fold12: mtry=38
- Fold12: mtry=38
+ Fold12: mtry=40
- Fold12: mtry=40
+ Fold12: mtry=42
- Fold12: mtry=42
+ Fold12: mtry=44
- Fold12: mtry=44
+ Fold12: mtry=46
- Fold12: mtry=46
+ Fold12: mtry=48
- Fold12: mtry=48
+ Fold12: mtry=50
- Fold12: mtry=50
+ Fold12: mtry=52
- Fold12: mtry=52
+ Fold12: mtry=54
- Fold12: mtry=54
+ Fold12: mtry=56
- Fold12: mtry=56
+ Fold12: mtry=58
- Fold12: mtry=58
+ Fold12: mtry=60
- Fold12: mtry=60
+ Fold12: mtry=62
- Fold12: mtry=62
+ Fold12: mtry=64
- Fold12: mtry=64
+ Fold12: mtry=66
- Fold12: mtry=66
+ Fold12: mtry=68
- Fold12: mtry=68
+ Fold12: mtry=70
- Fold12: mtry=70
+ Fold12: mtry=72
- Fold12: mtry=72
+ Fold12: mtry=74
- Fold12: mtry=74
+ Fold12: mtry=76
- Fold12: mtry=76
+ Fold13: mtry= 2
- Fold13: mtry= 2
+ Fold13: mtry= 4
- Fold13: mtry= 4
+ Fold13: mtry= 6
- Fold13: mtry= 6
+ Fold13: mtry= 8
- Fold13: mtry= 8
+ Fold13: mtry=10
- Fold13: mtry=10
+ Fold13: mtry=12
- Fold13: mtry=12
+ Fold13: mtry=14
- Fold13: mtry=14
+ Fold13: mtry=16
- Fold13: mtry=16
+ Fold13: mtry=18
- Fold13: mtry=18
+ Fold13: mtry=20
- Fold13: mtry=20
+ Fold13: mtry=22
- Fold13: mtry=22
+ Fold13: mtry=24
- Fold13: mtry=24
+ Fold13: mtry=26
- Fold13: mtry=26
+ Fold13: mtry=28
- Fold13: mtry=28
+ Fold13: mtry=30
- Fold13: mtry=30
+ Fold13: mtry=32
- Fold13: mtry=32
+ Fold13: mtry=34
- Fold13: mtry=34
+ Fold13: mtry=36
- Fold13: mtry=36
+ Fold13: mtry=38
- Fold13: mtry=38
+ Fold13: mtry=40
- Fold13: mtry=40
+ Fold13: mtry=42
- Fold13: mtry=42
+ Fold13: mtry=44
- Fold13: mtry=44
+ Fold13: mtry=46
- Fold13: mtry=46
+ Fold13: mtry=48
- Fold13: mtry=48
+ Fold13: mtry=50
- Fold13: mtry=50
+ Fold13: mtry=52
- Fold13: mtry=52
+ Fold13: mtry=54
- Fold13: mtry=54
+ Fold13: mtry=56
- Fold13: mtry=56
+ Fold13: mtry=58
- Fold13: mtry=58
+ Fold13: mtry=60
- Fold13: mtry=60
+ Fold13: mtry=62
- Fold13: mtry=62
+ Fold13: mtry=64
- Fold13: mtry=64
+ Fold13: mtry=66
- Fold13: mtry=66
+ Fold13: mtry=68
- Fold13: mtry=68
+ Fold13: mtry=70
- Fold13: mtry=70
+ Fold13: mtry=72
- Fold13: mtry=72
+ Fold13: mtry=74
- Fold13: mtry=74
+ Fold13: mtry=76
- Fold13: mtry=76
+ Fold14: mtry= 2
- Fold14: mtry= 2
+ Fold14: mtry= 4
- Fold14: mtry= 4
+ Fold14: mtry= 6
- Fold14: mtry= 6
+ Fold14: mtry= 8
- Fold14: mtry= 8
+ Fold14: mtry=10
- Fold14: mtry=10
+ Fold14: mtry=12
- Fold14: mtry=12
+ Fold14: mtry=14
- Fold14: mtry=14
+ Fold14: mtry=16
- Fold14: mtry=16
+ Fold14: mtry=18
- Fold14: mtry=18
+ Fold14: mtry=20
- Fold14: mtry=20
+ Fold14: mtry=22
- Fold14: mtry=22
+ Fold14: mtry=24
- Fold14: mtry=24
+ Fold14: mtry=26
- Fold14: mtry=26
+ Fold14: mtry=28
- Fold14: mtry=28
+ Fold14: mtry=30
- Fold14: mtry=30
+ Fold14: mtry=32
- Fold14: mtry=32
+ Fold14: mtry=34
- Fold14: mtry=34
+ Fold14: mtry=36
- Fold14: mtry=36
+ Fold14: mtry=38
- Fold14: mtry=38
+ Fold14: mtry=40
- Fold14: mtry=40
+ Fold14: mtry=42
- Fold14: mtry=42
+ Fold14: mtry=44
- Fold14: mtry=44
+ Fold14: mtry=46
- Fold14: mtry=46
+ Fold14: mtry=48
- Fold14: mtry=48
+ Fold14: mtry=50
- Fold14: mtry=50
+ Fold14: mtry=52
- Fold14: mtry=52
+ Fold14: mtry=54
- Fold14: mtry=54
+ Fold14: mtry=56
- Fold14: mtry=56
+ Fold14: mtry=58
- Fold14: mtry=58
+ Fold14: mtry=60
- Fold14: mtry=60
+ Fold14: mtry=62
- Fold14: mtry=62
+ Fold14: mtry=64
- Fold14: mtry=64
+ Fold14: mtry=66
- Fold14: mtry=66
+ Fold14: mtry=68
- Fold14: mtry=68
+ Fold14: mtry=70
- Fold14: mtry=70
+ Fold14: mtry=72
- Fold14: mtry=72
+ Fold14: mtry=74
- Fold14: mtry=74
+ Fold14: mtry=76
- Fold14: mtry=76
+ Fold15: mtry= 2
- Fold15: mtry= 2
+ Fold15: mtry= 4
- Fold15: mtry= 4
+ Fold15: mtry= 6
- Fold15: mtry= 6
+ Fold15: mtry= 8
- Fold15: mtry= 8
+ Fold15: mtry=10
- Fold15: mtry=10
+ Fold15: mtry=12
- Fold15: mtry=12
+ Fold15: mtry=14
- Fold15: mtry=14
+ Fold15: mtry=16
- Fold15: mtry=16
+ Fold15: mtry=18
- Fold15: mtry=18
+ Fold15: mtry=20
- Fold15: mtry=20
+ Fold15: mtry=22
- Fold15: mtry=22
+ Fold15: mtry=24
- Fold15: mtry=24
+ Fold15: mtry=26
- Fold15: mtry=26
+ Fold15: mtry=28
- Fold15: mtry=28
+ Fold15: mtry=30
- Fold15: mtry=30
+ Fold15: mtry=32
- Fold15: mtry=32
+ Fold15: mtry=34
- Fold15: mtry=34
+ Fold15: mtry=36
- Fold15: mtry=36
+ Fold15: mtry=38
- Fold15: mtry=38
+ Fold15: mtry=40
- Fold15: mtry=40
+ Fold15: mtry=42
- Fold15: mtry=42
+ Fold15: mtry=44
- Fold15: mtry=44
+ Fold15: mtry=46
- Fold15: mtry=46
+ Fold15: mtry=48
- Fold15: mtry=48
+ Fold15: mtry=50
- Fold15: mtry=50
+ Fold15: mtry=52
- Fold15: mtry=52
+ Fold15: mtry=54
- Fold15: mtry=54
+ Fold15: mtry=56
- Fold15: mtry=56
+ Fold15: mtry=58
- Fold15: mtry=58
+ Fold15: mtry=60
- Fold15: mtry=60
+ Fold15: mtry=62
- Fold15: mtry=62
+ Fold15: mtry=64
- Fold15: mtry=64
+ Fold15: mtry=66
- Fold15: mtry=66
+ Fold15: mtry=68
- Fold15: mtry=68
+ Fold15: mtry=70
- Fold15: mtry=70
+ Fold15: mtry=72
- Fold15: mtry=72
+ Fold15: mtry=74
- Fold15: mtry=74
+ Fold15: mtry=76
- Fold15: mtry=76
+ Fold16: mtry= 2
- Fold16: mtry= 2
+ Fold16: mtry= 4
- Fold16: mtry= 4
+ Fold16: mtry= 6
- Fold16: mtry= 6
+ Fold16: mtry= 8
- Fold16: mtry= 8
+ Fold16: mtry=10
- Fold16: mtry=10
+ Fold16: mtry=12
- Fold16: mtry=12
+ Fold16: mtry=14
- Fold16: mtry=14
+ Fold16: mtry=16
- Fold16: mtry=16
+ Fold16: mtry=18
- Fold16: mtry=18
+ Fold16: mtry=20
- Fold16: mtry=20
+ Fold16: mtry=22
- Fold16: mtry=22
+ Fold16: mtry=24
- Fold16: mtry=24
+ Fold16: mtry=26
- Fold16: mtry=26
+ Fold16: mtry=28
- Fold16: mtry=28
+ Fold16: mtry=30
- Fold16: mtry=30
+ Fold16: mtry=32
- Fold16: mtry=32
+ Fold16: mtry=34
- Fold16: mtry=34
+ Fold16: mtry=36
- Fold16: mtry=36
+ Fold16: mtry=38
- Fold16: mtry=38
+ Fold16: mtry=40
- Fold16: mtry=40
+ Fold16: mtry=42
- Fold16: mtry=42
+ Fold16: mtry=44
- Fold16: mtry=44
+ Fold16: mtry=46
- Fold16: mtry=46
+ Fold16: mtry=48
- Fold16: mtry=48
+ Fold16: mtry=50
- Fold16: mtry=50
+ Fold16: mtry=52
- Fold16: mtry=52
+ Fold16: mtry=54
- Fold16: mtry=54
+ Fold16: mtry=56
- Fold16: mtry=56
+ Fold16: mtry=58
- Fold16: mtry=58
+ Fold16: mtry=60
- Fold16: mtry=60
+ Fold16: mtry=62
- Fold16: mtry=62
+ Fold16: mtry=64
- Fold16: mtry=64
+ Fold16: mtry=66
- Fold16: mtry=66
+ Fold16: mtry=68
- Fold16: mtry=68
+ Fold16: mtry=70
- Fold16: mtry=70
+ Fold16: mtry=72
- Fold16: mtry=72
+ Fold16: mtry=74
- Fold16: mtry=74
+ Fold16: mtry=76
- Fold16: mtry=76
+ Fold17: mtry= 2
- Fold17: mtry= 2
+ Fold17: mtry= 4
- Fold17: mtry= 4
+ Fold17: mtry= 6
- Fold17: mtry= 6
+ Fold17: mtry= 8
- Fold17: mtry= 8
+ Fold17: mtry=10
- Fold17: mtry=10
+ Fold17: mtry=12
- Fold17: mtry=12
+ Fold17: mtry=14
- Fold17: mtry=14
+ Fold17: mtry=16
- Fold17: mtry=16
+ Fold17: mtry=18
- Fold17: mtry=18
+ Fold17: mtry=20
- Fold17: mtry=20
+ Fold17: mtry=22
- Fold17: mtry=22
+ Fold17: mtry=24
- Fold17: mtry=24
+ Fold17: mtry=26
- Fold17: mtry=26
+ Fold17: mtry=28
- Fold17: mtry=28
+ Fold17: mtry=30
- Fold17: mtry=30
+ Fold17: mtry=32
- Fold17: mtry=32
+ Fold17: mtry=34
- Fold17: mtry=34
+ Fold17: mtry=36
- Fold17: mtry=36
+ Fold17: mtry=38
- Fold17: mtry=38
+ Fold17: mtry=40
- Fold17: mtry=40
+ Fold17: mtry=42
- Fold17: mtry=42
+ Fold17: mtry=44
- Fold17: mtry=44
+ Fold17: mtry=46
- Fold17: mtry=46
+ Fold17: mtry=48
- Fold17: mtry=48
+ Fold17: mtry=50
- Fold17: mtry=50
+ Fold17: mtry=52
- Fold17: mtry=52
+ Fold17: mtry=54
- Fold17: mtry=54
+ Fold17: mtry=56
- Fold17: mtry=56
+ Fold17: mtry=58
- Fold17: mtry=58
+ Fold17: mtry=60
- Fold17: mtry=60
+ Fold17: mtry=62
- Fold17: mtry=62
+ Fold17: mtry=64
- Fold17: mtry=64
+ Fold17: mtry=66
- Fold17: mtry=66
+ Fold17: mtry=68
- Fold17: mtry=68
+ Fold17: mtry=70
- Fold17: mtry=70
+ Fold17: mtry=72
- Fold17: mtry=72
+ Fold17: mtry=74
- Fold17: mtry=74
+ Fold17: mtry=76
- Fold17: mtry=76
+ Fold18: mtry= 2
- Fold18: mtry= 2
+ Fold18: mtry= 4
- Fold18: mtry= 4
+ Fold18: mtry= 6
- Fold18: mtry= 6
+ Fold18: mtry= 8
- Fold18: mtry= 8
+ Fold18: mtry=10
- Fold18: mtry=10
+ Fold18: mtry=12
- Fold18: mtry=12
+ Fold18: mtry=14
- Fold18: mtry=14
+ Fold18: mtry=16
- Fold18: mtry=16
+ Fold18: mtry=18
- Fold18: mtry=18
+ Fold18: mtry=20
- Fold18: mtry=20
+ Fold18: mtry=22
- Fold18: mtry=22
+ Fold18: mtry=24
- Fold18: mtry=24
+ Fold18: mtry=26
- Fold18: mtry=26
+ Fold18: mtry=28
- Fold18: mtry=28
+ Fold18: mtry=30
- Fold18: mtry=30
+ Fold18: mtry=32
- Fold18: mtry=32
+ Fold18: mtry=34
- Fold18: mtry=34
+ Fold18: mtry=36
- Fold18: mtry=36
+ Fold18: mtry=38
- Fold18: mtry=38
+ Fold18: mtry=40
- Fold18: mtry=40
+ Fold18: mtry=42
- Fold18: mtry=42
+ Fold18: mtry=44
- Fold18: mtry=44
+ Fold18: mtry=46
- Fold18: mtry=46
+ Fold18: mtry=48
- Fold18: mtry=48
+ Fold18: mtry=50
- Fold18: mtry=50
+ Fold18: mtry=52
- Fold18: mtry=52
+ Fold18: mtry=54
- Fold18: mtry=54
+ Fold18: mtry=56
- Fold18: mtry=56
+ Fold18: mtry=58
- Fold18: mtry=58
+ Fold18: mtry=60
- Fold18: mtry=60
+ Fold18: mtry=62
- Fold18: mtry=62
+ Fold18: mtry=64
- Fold18: mtry=64
+ Fold18: mtry=66
- Fold18: mtry=66
+ Fold18: mtry=68
- Fold18: mtry=68
+ Fold18: mtry=70
- Fold18: mtry=70
+ Fold18: mtry=72
- Fold18: mtry=72
+ Fold18: mtry=74
- Fold18: mtry=74
+ Fold18: mtry=76
- Fold18: mtry=76
+ Fold19: mtry= 2
- Fold19: mtry= 2
+ Fold19: mtry= 4
- Fold19: mtry= 4
+ Fold19: mtry= 6
- Fold19: mtry= 6
+ Fold19: mtry= 8
- Fold19: mtry= 8
+ Fold19: mtry=10
- Fold19: mtry=10
+ Fold19: mtry=12
- Fold19: mtry=12
+ Fold19: mtry=14
- Fold19: mtry=14
+ Fold19: mtry=16
- Fold19: mtry=16
+ Fold19: mtry=18
- Fold19: mtry=18
+ Fold19: mtry=20
- Fold19: mtry=20
+ Fold19: mtry=22
- Fold19: mtry=22
+ Fold19: mtry=24
- Fold19: mtry=24
+ Fold19: mtry=26
- Fold19: mtry=26
+ Fold19: mtry=28
- Fold19: mtry=28
+ Fold19: mtry=30
- Fold19: mtry=30
+ Fold19: mtry=32
- Fold19: mtry=32
+ Fold19: mtry=34
- Fold19: mtry=34
+ Fold19: mtry=36
- Fold19: mtry=36
+ Fold19: mtry=38
- Fold19: mtry=38
+ Fold19: mtry=40
- Fold19: mtry=40
+ Fold19: mtry=42
- Fold19: mtry=42
+ Fold19: mtry=44
- Fold19: mtry=44
+ Fold19: mtry=46
- Fold19: mtry=46
+ Fold19: mtry=48
- Fold19: mtry=48
+ Fold19: mtry=50
- Fold19: mtry=50
+ Fold19: mtry=52
- Fold19: mtry=52
+ Fold19: mtry=54
- Fold19: mtry=54
+ Fold19: mtry=56
- Fold19: mtry=56
+ Fold19: mtry=58
- Fold19: mtry=58
+ Fold19: mtry=60
- Fold19: mtry=60
+ Fold19: mtry=62
- Fold19: mtry=62
+ Fold19: mtry=64
- Fold19: mtry=64
+ Fold19: mtry=66
- Fold19: mtry=66
+ Fold19: mtry=68
- Fold19: mtry=68
+ Fold19: mtry=70
- Fold19: mtry=70
+ Fold19: mtry=72
- Fold19: mtry=72
+ Fold19: mtry=74
- Fold19: mtry=74
+ Fold19: mtry=76
- Fold19: mtry=76
+ Fold20: mtry= 2
- Fold20: mtry= 2
+ Fold20: mtry= 4
- Fold20: mtry= 4
+ Fold20: mtry= 6
- Fold20: mtry= 6
+ Fold20: mtry= 8
- Fold20: mtry= 8
+ Fold20: mtry=10
- Fold20: mtry=10
+ Fold20: mtry=12
- Fold20: mtry=12
+ Fold20: mtry=14
- Fold20: mtry=14
+ Fold20: mtry=16
- Fold20: mtry=16
+ Fold20: mtry=18
- Fold20: mtry=18
+ Fold20: mtry=20
- Fold20: mtry=20
+ Fold20: mtry=22
- Fold20: mtry=22
+ Fold20: mtry=24
- Fold20: mtry=24
+ Fold20: mtry=26
- Fold20: mtry=26
+ Fold20: mtry=28
- Fold20: mtry=28
+ Fold20: mtry=30
- Fold20: mtry=30
+ Fold20: mtry=32
- Fold20: mtry=32
+ Fold20: mtry=34
- Fold20: mtry=34
+ Fold20: mtry=36
- Fold20: mtry=36
+ Fold20: mtry=38
- Fold20: mtry=38
+ Fold20: mtry=40
- Fold20: mtry=40
+ Fold20: mtry=42
- Fold20: mtry=42
+ Fold20: mtry=44
- Fold20: mtry=44
+ Fold20: mtry=46
- Fold20: mtry=46
+ Fold20: mtry=48
- Fold20: mtry=48
+ Fold20: mtry=50
- Fold20: mtry=50
+ Fold20: mtry=52
- Fold20: mtry=52
+ Fold20: mtry=54
- Fold20: mtry=54
+ Fold20: mtry=56
- Fold20: mtry=56
+ Fold20: mtry=58
- Fold20: mtry=58
+ Fold20: mtry=60
- Fold20: mtry=60
+ Fold20: mtry=62
- Fold20: mtry=62
+ Fold20: mtry=64
- Fold20: mtry=64
+ Fold20: mtry=66
- Fold20: mtry=66
+ Fold20: mtry=68
- Fold20: mtry=68
+ Fold20: mtry=70
- Fold20: mtry=70
+ Fold20: mtry=72
- Fold20: mtry=72
+ Fold20: mtry=74
- Fold20: mtry=74
+ Fold20: mtry=76
- Fold20: mtry=76
+ Fold21: mtry= 2
- Fold21: mtry= 2
+ Fold21: mtry= 4
- Fold21: mtry= 4
+ Fold21: mtry= 6
- Fold21: mtry= 6
+ Fold21: mtry= 8
- Fold21: mtry= 8
+ Fold21: mtry=10
- Fold21: mtry=10
+ Fold21: mtry=12
- Fold21: mtry=12
+ Fold21: mtry=14
- Fold21: mtry=14
+ Fold21: mtry=16
- Fold21: mtry=16
+ Fold21: mtry=18
- Fold21: mtry=18
+ Fold21: mtry=20
- Fold21: mtry=20
+ Fold21: mtry=22
- Fold21: mtry=22
+ Fold21: mtry=24
- Fold21: mtry=24
+ Fold21: mtry=26
- Fold21: mtry=26
+ Fold21: mtry=28
- Fold21: mtry=28
+ Fold21: mtry=30
- Fold21: mtry=30
+ Fold21: mtry=32
- Fold21: mtry=32
+ Fold21: mtry=34
- Fold21: mtry=34
+ Fold21: mtry=36
- Fold21: mtry=36
+ Fold21: mtry=38
- Fold21: mtry=38
+ Fold21: mtry=40
- Fold21: mtry=40
+ Fold21: mtry=42
- Fold21: mtry=42
+ Fold21: mtry=44
- Fold21: mtry=44
+ Fold21: mtry=46
- Fold21: mtry=46
+ Fold21: mtry=48
- Fold21: mtry=48
+ Fold21: mtry=50
- Fold21: mtry=50
+ Fold21: mtry=52
- Fold21: mtry=52
+ Fold21: mtry=54
- Fold21: mtry=54
+ Fold21: mtry=56
- Fold21: mtry=56
+ Fold21: mtry=58
- Fold21: mtry=58
+ Fold21: mtry=60
- Fold21: mtry=60
+ Fold21: mtry=62
- Fold21: mtry=62
+ Fold21: mtry=64
- Fold21: mtry=64
+ Fold21: mtry=66
- Fold21: mtry=66
+ Fold21: mtry=68
- Fold21: mtry=68
+ Fold21: mtry=70
- Fold21: mtry=70
+ Fold21: mtry=72
- Fold21: mtry=72
+ Fold21: mtry=74
- Fold21: mtry=74
+ Fold21: mtry=76
- Fold21: mtry=76
+ Fold22: mtry= 2
- Fold22: mtry= 2
+ Fold22: mtry= 4
- Fold22: mtry= 4
+ Fold22: mtry= 6
- Fold22: mtry= 6
+ Fold22: mtry= 8
- Fold22: mtry= 8
+ Fold22: mtry=10
- Fold22: mtry=10
+ Fold22: mtry=12
- Fold22: mtry=12
+ Fold22: mtry=14
- Fold22: mtry=14
+ Fold22: mtry=16
- Fold22: mtry=16
+ Fold22: mtry=18
- Fold22: mtry=18
+ Fold22: mtry=20
- Fold22: mtry=20
+ Fold22: mtry=22
- Fold22: mtry=22
+ Fold22: mtry=24
- Fold22: mtry=24
+ Fold22: mtry=26
- Fold22: mtry=26
+ Fold22: mtry=28
- Fold22: mtry=28
+ Fold22: mtry=30
- Fold22: mtry=30
+ Fold22: mtry=32
- Fold22: mtry=32
+ Fold22: mtry=34
- Fold22: mtry=34
+ Fold22: mtry=36
- Fold22: mtry=36
+ Fold22: mtry=38
- Fold22: mtry=38
+ Fold22: mtry=40
- Fold22: mtry=40
+ Fold22: mtry=42
- Fold22: mtry=42
+ Fold22: mtry=44
- Fold22: mtry=44
+ Fold22: mtry=46
- Fold22: mtry=46
+ Fold22: mtry=48
- Fold22: mtry=48
+ Fold22: mtry=50
- Fold22: mtry=50
+ Fold22: mtry=52
- Fold22: mtry=52
+ Fold22: mtry=54
- Fold22: mtry=54
+ Fold22: mtry=56
- Fold22: mtry=56
+ Fold22: mtry=58
- Fold22: mtry=58
+ Fold22: mtry=60
- Fold22: mtry=60
+ Fold22: mtry=62
- Fold22: mtry=62
+ Fold22: mtry=64
- Fold22: mtry=64
+ Fold22: mtry=66
- Fold22: mtry=66
+ Fold22: mtry=68
- Fold22: mtry=68
+ Fold22: mtry=70
- Fold22: mtry=70
+ Fold22: mtry=72
- Fold22: mtry=72
+ Fold22: mtry=74
- Fold22: mtry=74
+ Fold22: mtry=76
- Fold22: mtry=76
+ Fold23: mtry= 2
- Fold23: mtry= 2
+ Fold23: mtry= 4
- Fold23: mtry= 4
+ Fold23: mtry= 6
- Fold23: mtry= 6
+ Fold23: mtry= 8
- Fold23: mtry= 8
+ Fold23: mtry=10
- Fold23: mtry=10
+ Fold23: mtry=12
- Fold23: mtry=12
+ Fold23: mtry=14
- Fold23: mtry=14
+ Fold23: mtry=16
- Fold23: mtry=16
+ Fold23: mtry=18
- Fold23: mtry=18
+ Fold23: mtry=20
- Fold23: mtry=20
+ Fold23: mtry=22
- Fold23: mtry=22
+ Fold23: mtry=24
- Fold23: mtry=24
+ Fold23: mtry=26
- Fold23: mtry=26
+ Fold23: mtry=28
- Fold23: mtry=28
+ Fold23: mtry=30
- Fold23: mtry=30
+ Fold23: mtry=32
- Fold23: mtry=32
+ Fold23: mtry=34
- Fold23: mtry=34
+ Fold23: mtry=36
- Fold23: mtry=36
+ Fold23: mtry=38
- Fold23: mtry=38
+ Fold23: mtry=40
- Fold23: mtry=40
+ Fold23: mtry=42
- Fold23: mtry=42
+ Fold23: mtry=44
- Fold23: mtry=44
+ Fold23: mtry=46
- Fold23: mtry=46
+ Fold23: mtry=48
- Fold23: mtry=48
+ Fold23: mtry=50
- Fold23: mtry=50
+ Fold23: mtry=52
- Fold23: mtry=52
+ Fold23: mtry=54
- Fold23: mtry=54
+ Fold23: mtry=56
- Fold23: mtry=56
+ Fold23: mtry=58
- Fold23: mtry=58
+ Fold23: mtry=60
- Fold23: mtry=60
+ Fold23: mtry=62
- Fold23: mtry=62
+ Fold23: mtry=64
- Fold23: mtry=64
+ Fold23: mtry=66
- Fold23: mtry=66
+ Fold23: mtry=68
- Fold23: mtry=68
+ Fold23: mtry=70
- Fold23: mtry=70
+ Fold23: mtry=72
- Fold23: mtry=72
+ Fold23: mtry=74
- Fold23: mtry=74
+ Fold23: mtry=76
- Fold23: mtry=76
+ Fold24: mtry= 2
- Fold24: mtry= 2
+ Fold24: mtry= 4
- Fold24: mtry= 4
+ Fold24: mtry= 6
- Fold24: mtry= 6
+ Fold24: mtry= 8
- Fold24: mtry= 8
+ Fold24: mtry=10
- Fold24: mtry=10
+ Fold24: mtry=12
- Fold24: mtry=12
+ Fold24: mtry=14
- Fold24: mtry=14
+ Fold24: mtry=16
- Fold24: mtry=16
+ Fold24: mtry=18
- Fold24: mtry=18
+ Fold24: mtry=20
- Fold24: mtry=20
+ Fold24: mtry=22
- Fold24: mtry=22
+ Fold24: mtry=24
- Fold24: mtry=24
+ Fold24: mtry=26
- Fold24: mtry=26
+ Fold24: mtry=28
- Fold24: mtry=28
+ Fold24: mtry=30
- Fold24: mtry=30
+ Fold24: mtry=32
- Fold24: mtry=32
+ Fold24: mtry=34
- Fold24: mtry=34
+ Fold24: mtry=36
- Fold24: mtry=36
+ Fold24: mtry=38
- Fold24: mtry=38
+ Fold24: mtry=40
- Fold24: mtry=40
+ Fold24: mtry=42
- Fold24: mtry=42
+ Fold24: mtry=44
- Fold24: mtry=44
+ Fold24: mtry=46
- Fold24: mtry=46
+ Fold24: mtry=48
- Fold24: mtry=48
+ Fold24: mtry=50
- Fold24: mtry=50
+ Fold24: mtry=52
- Fold24: mtry=52
+ Fold24: mtry=54
- Fold24: mtry=54
+ Fold24: mtry=56
- Fold24: mtry=56
+ Fold24: mtry=58
- Fold24: mtry=58
+ Fold24: mtry=60
- Fold24: mtry=60
+ Fold24: mtry=62
- Fold24: mtry=62
+ Fold24: mtry=64
- Fold24: mtry=64
+ Fold24: mtry=66
- Fold24: mtry=66
+ Fold24: mtry=68
- Fold24: mtry=68
+ Fold24: mtry=70
- Fold24: mtry=70
+ Fold24: mtry=72
- Fold24: mtry=72
+ Fold24: mtry=74
- Fold24: mtry=74
+ Fold24: mtry=76
- Fold24: mtry=76
+ Fold25: mtry= 2
- Fold25: mtry= 2
+ Fold25: mtry= 4
- Fold25: mtry= 4
+ Fold25: mtry= 6
- Fold25: mtry= 6
+ Fold25: mtry= 8
- Fold25: mtry= 8
+ Fold25: mtry=10
- Fold25: mtry=10
+ Fold25: mtry=12
- Fold25: mtry=12
+ Fold25: mtry=14
- Fold25: mtry=14
+ Fold25: mtry=16
- Fold25: mtry=16
+ Fold25: mtry=18
- Fold25: mtry=18
+ Fold25: mtry=20
- Fold25: mtry=20
+ Fold25: mtry=22
- Fold25: mtry=22
+ Fold25: mtry=24
- Fold25: mtry=24
+ Fold25: mtry=26
- Fold25: mtry=26
+ Fold25: mtry=28
- Fold25: mtry=28
+ Fold25: mtry=30
- Fold25: mtry=30
+ Fold25: mtry=32
- Fold25: mtry=32
+ Fold25: mtry=34
- Fold25: mtry=34
+ Fold25: mtry=36
- Fold25: mtry=36
+ Fold25: mtry=38
- Fold25: mtry=38
+ Fold25: mtry=40
- Fold25: mtry=40
+ Fold25: mtry=42
- Fold25: mtry=42
+ Fold25: mtry=44
- Fold25: mtry=44
+ Fold25: mtry=46
- Fold25: mtry=46
+ Fold25: mtry=48
- Fold25: mtry=48
+ Fold25: mtry=50
- Fold25: mtry=50
+ Fold25: mtry=52
- Fold25: mtry=52
+ Fold25: mtry=54
- Fold25: mtry=54
+ Fold25: mtry=56
- Fold25: mtry=56
+ Fold25: mtry=58
- Fold25: mtry=58
+ Fold25: mtry=60
- Fold25: mtry=60
+ Fold25: mtry=62
- Fold25: mtry=62
+ Fold25: mtry=64
- Fold25: mtry=64
+ Fold25: mtry=66
- Fold25: mtry=66
+ Fold25: mtry=68
- Fold25: mtry=68
+ Fold25: mtry=70
- Fold25: mtry=70
+ Fold25: mtry=72
- Fold25: mtry=72
+ Fold25: mtry=74
- Fold25: mtry=74
+ Fold25: mtry=76
- Fold25: mtry=76
+ Fold26: mtry= 2
- Fold26: mtry= 2
+ Fold26: mtry= 4
- Fold26: mtry= 4
+ Fold26: mtry= 6
- Fold26: mtry= 6
+ Fold26: mtry= 8
- Fold26: mtry= 8
+ Fold26: mtry=10
- Fold26: mtry=10
+ Fold26: mtry=12
- Fold26: mtry=12
+ Fold26: mtry=14
- Fold26: mtry=14
+ Fold26: mtry=16
- Fold26: mtry=16
+ Fold26: mtry=18
- Fold26: mtry=18
+ Fold26: mtry=20
- Fold26: mtry=20
+ Fold26: mtry=22
- Fold26: mtry=22
+ Fold26: mtry=24
- Fold26: mtry=24
+ Fold26: mtry=26
- Fold26: mtry=26
+ Fold26: mtry=28
- Fold26: mtry=28
+ Fold26: mtry=30
- Fold26: mtry=30
+ Fold26: mtry=32
- Fold26: mtry=32
+ Fold26: mtry=34
- Fold26: mtry=34
+ Fold26: mtry=36
- Fold26: mtry=36
+ Fold26: mtry=38
- Fold26: mtry=38
+ Fold26: mtry=40
- Fold26: mtry=40
+ Fold26: mtry=42
- Fold26: mtry=42
+ Fold26: mtry=44
- Fold26: mtry=44
+ Fold26: mtry=46
- Fold26: mtry=46
+ Fold26: mtry=48
- Fold26: mtry=48
+ Fold26: mtry=50
- Fold26: mtry=50
+ Fold26: mtry=52
- Fold26: mtry=52
+ Fold26: mtry=54
- Fold26: mtry=54
+ Fold26: mtry=56
- Fold26: mtry=56
+ Fold26: mtry=58
- Fold26: mtry=58
+ Fold26: mtry=60
- Fold26: mtry=60
+ Fold26: mtry=62
- Fold26: mtry=62
+ Fold26: mtry=64
- Fold26: mtry=64
+ Fold26: mtry=66
- Fold26: mtry=66
+ Fold26: mtry=68
- Fold26: mtry=68
+ Fold26: mtry=70
- Fold26: mtry=70
+ Fold26: mtry=72
- Fold26: mtry=72
+ Fold26: mtry=74
- Fold26: mtry=74
+ Fold26: mtry=76
- Fold26: mtry=76
+ Fold27: mtry= 2
- Fold27: mtry= 2
+ Fold27: mtry= 4
- Fold27: mtry= 4
+ Fold27: mtry= 6
- Fold27: mtry= 6
+ Fold27: mtry= 8
- Fold27: mtry= 8
+ Fold27: mtry=10
- Fold27: mtry=10
+ Fold27: mtry=12
- Fold27: mtry=12
+ Fold27: mtry=14
- Fold27: mtry=14
+ Fold27: mtry=16
- Fold27: mtry=16
+ Fold27: mtry=18
- Fold27: mtry=18
+ Fold27: mtry=20
- Fold27: mtry=20
+ Fold27: mtry=22
- Fold27: mtry=22
+ Fold27: mtry=24
- Fold27: mtry=24
+ Fold27: mtry=26
- Fold27: mtry=26
+ Fold27: mtry=28
- Fold27: mtry=28
+ Fold27: mtry=30
- Fold27: mtry=30
+ Fold27: mtry=32
- Fold27: mtry=32
+ Fold27: mtry=34
- Fold27: mtry=34
+ Fold27: mtry=36
- Fold27: mtry=36
+ Fold27: mtry=38
- Fold27: mtry=38
+ Fold27: mtry=40
- Fold27: mtry=40
+ Fold27: mtry=42
- Fold27: mtry=42
+ Fold27: mtry=44
- Fold27: mtry=44
+ Fold27: mtry=46
- Fold27: mtry=46
+ Fold27: mtry=48
- Fold27: mtry=48
+ Fold27: mtry=50
- Fold27: mtry=50
+ Fold27: mtry=52
- Fold27: mtry=52
+ Fold27: mtry=54
- Fold27: mtry=54
+ Fold27: mtry=56
- Fold27: mtry=56
+ Fold27: mtry=58
- Fold27: mtry=58
+ Fold27: mtry=60
- Fold27: mtry=60
+ Fold27: mtry=62
- Fold27: mtry=62
+ Fold27: mtry=64
- Fold27: mtry=64
+ Fold27: mtry=66
- Fold27: mtry=66
+ Fold27: mtry=68
- Fold27: mtry=68
+ Fold27: mtry=70
- Fold27: mtry=70
+ Fold27: mtry=72
- Fold27: mtry=72
+ Fold27: mtry=74
- Fold27: mtry=74
+ Fold27: mtry=76
- Fold27: mtry=76
+ Fold28: mtry= 2
- Fold28: mtry= 2
+ Fold28: mtry= 4
- Fold28: mtry= 4
+ Fold28: mtry= 6
- Fold28: mtry= 6
+ Fold28: mtry= 8
- Fold28: mtry= 8
+ Fold28: mtry=10
- Fold28: mtry=10
+ Fold28: mtry=12
- Fold28: mtry=12
+ Fold28: mtry=14
- Fold28: mtry=14
+ Fold28: mtry=16
- Fold28: mtry=16
+ Fold28: mtry=18
- Fold28: mtry=18
+ Fold28: mtry=20
- Fold28: mtry=20
+ Fold28: mtry=22
- Fold28: mtry=22
+ Fold28: mtry=24
- Fold28: mtry=24
+ Fold28: mtry=26
- Fold28: mtry=26
+ Fold28: mtry=28
- Fold28: mtry=28
+ Fold28: mtry=30
- Fold28: mtry=30
+ Fold28: mtry=32
- Fold28: mtry=32
+ Fold28: mtry=34
- Fold28: mtry=34
+ Fold28: mtry=36
- Fold28: mtry=36
+ Fold28: mtry=38
- Fold28: mtry=38
+ Fold28: mtry=40
- Fold28: mtry=40
+ Fold28: mtry=42
- Fold28: mtry=42
+ Fold28: mtry=44
- Fold28: mtry=44
+ Fold28: mtry=46
- Fold28: mtry=46
+ Fold28: mtry=48
- Fold28: mtry=48
+ Fold28: mtry=50
- Fold28: mtry=50
+ Fold28: mtry=52
- Fold28: mtry=52
+ Fold28: mtry=54
- Fold28: mtry=54
+ Fold28: mtry=56
- Fold28: mtry=56
+ Fold28: mtry=58
- Fold28: mtry=58
+ Fold28: mtry=60
- Fold28: mtry=60
+ Fold28: mtry=62
- Fold28: mtry=62
+ Fold28: mtry=64
- Fold28: mtry=64
+ Fold28: mtry=66
- Fold28: mtry=66
+ Fold28: mtry=68
- Fold28: mtry=68
+ Fold28: mtry=70
- Fold28: mtry=70
+ Fold28: mtry=72
- Fold28: mtry=72
+ Fold28: mtry=74
- Fold28: mtry=74
+ Fold28: mtry=76
- Fold28: mtry=76
Aggregating results
Selecting tuning parameters
Fitting mtry = 66 on full training set# View results
print(rf_model)Random Forest
28 samples
77 predictors
Pre-processing: scaled (77), centered (77)
Resampling: Leave-One-Out Cross-Validation
Summary of sample sizes: 27, 27, 27, 27, 27, 27, ...
Resampling results across tuning parameters:
mtry RMSE Rsquared MAE
2 0.1319076 0.7307622 0.10400154
4 0.1247448 0.7345051 0.10045831
6 0.1173711 0.7516734 0.09529038
8 0.1111302 0.7807532 0.08979518
10 0.1101170 0.7777265 0.08891742
12 0.1129948 0.7573879 0.09218351
14 0.1097014 0.7650401 0.09202429
16 0.1117997 0.7489663 0.09291841
18 0.1082932 0.7662454 0.08936235
20 0.1062386 0.7761468 0.08789160
22 0.1036523 0.7842697 0.08666169
24 0.1033955 0.7873550 0.08715356
26 0.1056844 0.7758383 0.08863065
28 0.1083445 0.7587687 0.09065624
30 0.1055486 0.7692320 0.08782592
32 0.1067974 0.7647826 0.09035509
34 0.1048251 0.7738961 0.08809291
36 0.1031659 0.7835676 0.08621945
38 0.1021361 0.7887114 0.08708167
40 0.1034123 0.7771168 0.08734699
42 0.1025685 0.7835034 0.08709742
44 0.1052106 0.7646120 0.08897143
46 0.1045910 0.7718242 0.08898486
48 0.1042532 0.7708851 0.08819778
50 0.1015653 0.7847023 0.08687486
52 0.1050730 0.7684176 0.08914126
54 0.1028900 0.7807736 0.08708026
56 0.1034407 0.7761208 0.08852871
58 0.1015831 0.7876578 0.08736605
60 0.1016937 0.7832458 0.08727626
62 0.1041686 0.7693761 0.08880747
64 0.1049347 0.7638845 0.09081583
66 0.1014847 0.7858326 0.08689145
68 0.1029796 0.7755602 0.08886616
70 0.1041884 0.7707315 0.08921879
72 0.1035858 0.7732422 0.08916650
74 0.1035339 0.7751298 0.09004063
76 0.1041359 0.7704159 0.08982766
RMSE was used to select the optimal model using the smallest value.
The final value used for the model was mtry = 66.plot(rf_model) # Plot performance across hyperparameters
varImpPlot(rf_model$finalModel) # Plot variable importance
Gradient boosting
gbm_grid <- expand.grid(
n.trees = c(50, 100, 200), # Fewer trees
interaction.depth = c(1, 2, 3), # Much smaller tree depth
shrinkage = c(0.01, 0.05, 0.1), # Keep these values
n.minobsinnode = c(1, 3, 5) # Smaller minimum observations
)
gbm_model <- train(
mean_trans_docs ~ .,
data = data_models,
method = "gbm",
preProc = c('scale', 'center'),
trControl = control,
tuneGrid = gbm_grid)+ Fold01: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0438 nan 0.0100 0.0005
2 0.0434 nan 0.0100 0.0002
3 0.0428 nan 0.0100 0.0006
4 0.0423 nan 0.0100 0.0005
5 0.0417 nan 0.0100 0.0005
6 0.0411 nan 0.0100 0.0006
7 0.0406 nan 0.0100 0.0004
8 0.0400 nan 0.0100 0.0004
9 0.0396 nan 0.0100 0.0002
10 0.0393 nan 0.0100 0.0003
20 0.0349 nan 0.0100 0.0001
40 0.0277 nan 0.0100 0.0002
60 0.0219 nan 0.0100 0.0002
80 0.0175 nan 0.0100 0.0002
100 0.0142 nan 0.0100 0.0000
120 0.0120 nan 0.0100 0.0000
140 0.0101 nan 0.0100 0.0001
160 0.0085 nan 0.0100 0.0001
180 0.0071 nan 0.0100 0.0001
200 0.0061 nan 0.0100 0.0000
- Fold01: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold01: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0437 nan 0.0100 0.0006
2 0.0431 nan 0.0100 0.0004
3 0.0426 nan 0.0100 0.0001
4 0.0421 nan 0.0100 0.0005
5 0.0415 nan 0.0100 0.0003
6 0.0411 nan 0.0100 0.0004
7 0.0406 nan 0.0100 0.0003
8 0.0400 nan 0.0100 0.0004
9 0.0394 nan 0.0100 0.0003
10 0.0387 nan 0.0100 0.0006
20 0.0345 nan 0.0100 0.0004
40 0.0273 nan 0.0100 0.0003
60 0.0218 nan 0.0100 0.0002
80 0.0174 nan 0.0100 0.0001
100 0.0141 nan 0.0100 0.0001
120 0.0119 nan 0.0100 0.0001
140 0.0100 nan 0.0100 0.0000
160 0.0083 nan 0.0100 0.0001
180 0.0069 nan 0.0100 0.0001
200 0.0058 nan 0.0100 0.0000
- Fold01: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold01: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0441 nan 0.0100 0.0001
2 0.0436 nan 0.0100 0.0004
3 0.0432 nan 0.0100 0.0002
4 0.0426 nan 0.0100 0.0006
5 0.0422 nan 0.0100 -0.0000
6 0.0416 nan 0.0100 0.0005
7 0.0413 nan 0.0100 0.0003
8 0.0408 nan 0.0100 0.0005
9 0.0402 nan 0.0100 0.0006
10 0.0398 nan 0.0100 0.0002
20 0.0360 nan 0.0100 -0.0000
40 0.0287 nan 0.0100 -0.0001
60 0.0235 nan 0.0100 0.0001
80 0.0192 nan 0.0100 0.0002
100 0.0162 nan 0.0100 -0.0000
120 0.0139 nan 0.0100 -0.0000
140 0.0120 nan 0.0100 0.0001
160 0.0104 nan 0.0100 0.0001
180 0.0092 nan 0.0100 -0.0000
200 0.0081 nan 0.0100 0.0000
- Fold01: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold01: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0441 nan 0.0100 0.0001
2 0.0434 nan 0.0100 0.0005
3 0.0427 nan 0.0100 0.0005
4 0.0421 nan 0.0100 0.0005
5 0.0415 nan 0.0100 0.0005
6 0.0410 nan 0.0100 0.0005
7 0.0404 nan 0.0100 0.0006
8 0.0398 nan 0.0100 0.0003
9 0.0392 nan 0.0100 0.0007
10 0.0386 nan 0.0100 0.0004
20 0.0334 nan 0.0100 0.0006
40 0.0248 nan 0.0100 0.0002
60 0.0189 nan 0.0100 0.0001
80 0.0144 nan 0.0100 0.0002
100 0.0113 nan 0.0100 0.0001
120 0.0091 nan 0.0100 0.0000
140 0.0073 nan 0.0100 0.0000
160 0.0058 nan 0.0100 0.0000
180 0.0047 nan 0.0100 0.0000
200 0.0036 nan 0.0100 0.0000
- Fold01: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold01: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0438 nan 0.0100 0.0004
2 0.0431 nan 0.0100 0.0004
3 0.0425 nan 0.0100 0.0006
4 0.0418 nan 0.0100 0.0007
5 0.0414 nan 0.0100 0.0002
6 0.0409 nan 0.0100 0.0004
7 0.0404 nan 0.0100 0.0001
8 0.0398 nan 0.0100 0.0003
9 0.0393 nan 0.0100 0.0004
10 0.0386 nan 0.0100 0.0005
20 0.0336 nan 0.0100 0.0003
40 0.0257 nan 0.0100 0.0003
60 0.0202 nan 0.0100 0.0002
80 0.0158 nan 0.0100 0.0002
100 0.0126 nan 0.0100 0.0000
120 0.0099 nan 0.0100 0.0001
140 0.0081 nan 0.0100 0.0000
160 0.0066 nan 0.0100 0.0000
180 0.0054 nan 0.0100 -0.0000
200 0.0044 nan 0.0100 0.0000
- Fold01: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold01: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0441 nan 0.0100 0.0004
2 0.0435 nan 0.0100 0.0005
3 0.0432 nan 0.0100 -0.0002
4 0.0428 nan 0.0100 0.0001
5 0.0423 nan 0.0100 0.0005
6 0.0418 nan 0.0100 0.0005
7 0.0411 nan 0.0100 0.0006
8 0.0405 nan 0.0100 0.0002
9 0.0399 nan 0.0100 0.0005
10 0.0396 nan 0.0100 0.0003
20 0.0351 nan 0.0100 0.0000
40 0.0285 nan 0.0100 0.0004
60 0.0228 nan 0.0100 0.0002
80 0.0187 nan 0.0100 0.0002
100 0.0159 nan 0.0100 0.0001
120 0.0134 nan 0.0100 0.0001
140 0.0113 nan 0.0100 0.0001
160 0.0102 nan 0.0100 0.0000
180 0.0092 nan 0.0100 0.0000
200 0.0081 nan 0.0100 0.0000
- Fold01: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold01: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0438 nan 0.0100 0.0007
2 0.0431 nan 0.0100 0.0004
3 0.0425 nan 0.0100 0.0006
4 0.0418 nan 0.0100 0.0003
5 0.0411 nan 0.0100 0.0006
6 0.0404 nan 0.0100 0.0005
7 0.0399 nan 0.0100 0.0002
8 0.0395 nan 0.0100 0.0003
9 0.0386 nan 0.0100 0.0011
10 0.0379 nan 0.0100 0.0002
20 0.0328 nan 0.0100 0.0005
40 0.0245 nan 0.0100 0.0005
60 0.0181 nan 0.0100 0.0003
80 0.0137 nan 0.0100 0.0001
100 0.0106 nan 0.0100 0.0000
120 0.0082 nan 0.0100 0.0001
140 0.0065 nan 0.0100 0.0000
160 0.0051 nan 0.0100 0.0000
180 0.0040 nan 0.0100 -0.0000
200 0.0031 nan 0.0100 0.0000
- Fold01: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold01: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0438 nan 0.0100 0.0004
2 0.0431 nan 0.0100 0.0005
3 0.0425 nan 0.0100 0.0006
4 0.0419 nan 0.0100 0.0005
5 0.0415 nan 0.0100 0.0002
6 0.0409 nan 0.0100 0.0002
7 0.0403 nan 0.0100 0.0005
8 0.0398 nan 0.0100 0.0004
9 0.0394 nan 0.0100 0.0004
10 0.0389 nan 0.0100 0.0003
20 0.0335 nan 0.0100 0.0006
40 0.0256 nan 0.0100 0.0002
60 0.0193 nan 0.0100 0.0003
80 0.0151 nan 0.0100 0.0002
100 0.0119 nan 0.0100 0.0001
120 0.0095 nan 0.0100 0.0001
140 0.0074 nan 0.0100 0.0001
160 0.0061 nan 0.0100 0.0000
180 0.0050 nan 0.0100 -0.0000
200 0.0042 nan 0.0100 0.0000
- Fold01: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold01: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0438 nan 0.0100 0.0005
2 0.0434 nan 0.0100 0.0004
3 0.0428 nan 0.0100 0.0006
4 0.0423 nan 0.0100 0.0004
5 0.0418 nan 0.0100 0.0005
6 0.0412 nan 0.0100 0.0005
7 0.0408 nan 0.0100 0.0005
8 0.0401 nan 0.0100 0.0006
9 0.0398 nan 0.0100 0.0003
10 0.0392 nan 0.0100 0.0006
20 0.0348 nan 0.0100 0.0005
40 0.0274 nan 0.0100 0.0002
60 0.0222 nan 0.0100 0.0002
80 0.0180 nan 0.0100 0.0002
100 0.0151 nan 0.0100 0.0001
120 0.0129 nan 0.0100 0.0000
140 0.0113 nan 0.0100 0.0001
160 0.0097 nan 0.0100 0.0001
180 0.0086 nan 0.0100 0.0000
200 0.0076 nan 0.0100 0.0000
- Fold01: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold01: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0431 nan 0.0500 0.0010
2 0.0403 nan 0.0500 0.0029
3 0.0384 nan 0.0500 0.0013
4 0.0358 nan 0.0500 0.0026
5 0.0338 nan 0.0500 0.0015
6 0.0325 nan 0.0500 0.0011
7 0.0312 nan 0.0500 -0.0000
8 0.0303 nan 0.0500 0.0001
9 0.0290 nan 0.0500 0.0007
10 0.0275 nan 0.0500 0.0007
20 0.0170 nan 0.0500 0.0006
40 0.0064 nan 0.0500 -0.0000
60 0.0031 nan 0.0500 -0.0001
80 0.0016 nan 0.0500 -0.0000
100 0.0011 nan 0.0500 -0.0000
120 0.0007 nan 0.0500 -0.0000
140 0.0004 nan 0.0500 -0.0000
160 0.0003 nan 0.0500 -0.0000
180 0.0002 nan 0.0500 0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold01: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold01: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0422 nan 0.0500 0.0016
2 0.0390 nan 0.0500 0.0025
3 0.0359 nan 0.0500 0.0021
4 0.0331 nan 0.0500 0.0018
5 0.0308 nan 0.0500 0.0018
6 0.0299 nan 0.0500 0.0005
7 0.0282 nan 0.0500 0.0015
8 0.0268 nan 0.0500 0.0012
9 0.0251 nan 0.0500 0.0014
10 0.0241 nan 0.0500 0.0010
20 0.0136 nan 0.0500 0.0004
40 0.0060 nan 0.0500 0.0002
60 0.0034 nan 0.0500 0.0001
80 0.0018 nan 0.0500 -0.0000
100 0.0012 nan 0.0500 -0.0000
120 0.0008 nan 0.0500 0.0000
140 0.0005 nan 0.0500 0.0000
160 0.0003 nan 0.0500 0.0000
180 0.0002 nan 0.0500 0.0000
200 0.0002 nan 0.0500 -0.0000
- Fold01: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold01: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0424 nan 0.0500 0.0011
2 0.0416 nan 0.0500 -0.0011
3 0.0393 nan 0.0500 0.0027
4 0.0378 nan 0.0500 0.0015
5 0.0349 nan 0.0500 0.0014
6 0.0330 nan 0.0500 0.0020
7 0.0314 nan 0.0500 0.0020
8 0.0295 nan 0.0500 0.0018
9 0.0279 nan 0.0500 0.0013
10 0.0262 nan 0.0500 0.0016
20 0.0163 nan 0.0500 0.0003
40 0.0084 nan 0.0500 0.0002
60 0.0053 nan 0.0500 0.0001
80 0.0032 nan 0.0500 -0.0000
100 0.0024 nan 0.0500 -0.0001
120 0.0018 nan 0.0500 -0.0000
140 0.0014 nan 0.0500 -0.0000
160 0.0011 nan 0.0500 -0.0000
180 0.0009 nan 0.0500 0.0000
200 0.0006 nan 0.0500 -0.0000
- Fold01: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold01: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0415 nan 0.0500 0.0017
2 0.0391 nan 0.0500 0.0010
3 0.0358 nan 0.0500 0.0028
4 0.0329 nan 0.0500 0.0026
5 0.0308 nan 0.0500 0.0020
6 0.0285 nan 0.0500 0.0025
7 0.0274 nan 0.0500 0.0006
8 0.0250 nan 0.0500 0.0020
9 0.0232 nan 0.0500 0.0014
10 0.0220 nan 0.0500 0.0007
20 0.0116 nan 0.0500 0.0009
40 0.0035 nan 0.0500 0.0001
60 0.0013 nan 0.0500 0.0000
80 0.0005 nan 0.0500 0.0000
100 0.0002 nan 0.0500 0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0001 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold01: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold01: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0419 nan 0.0500 0.0025
2 0.0386 nan 0.0500 0.0021
3 0.0362 nan 0.0500 0.0022
4 0.0332 nan 0.0500 0.0024
5 0.0306 nan 0.0500 0.0008
6 0.0292 nan 0.0500 0.0007
7 0.0268 nan 0.0500 0.0022
8 0.0250 nan 0.0500 0.0011
9 0.0232 nan 0.0500 0.0019
10 0.0213 nan 0.0500 0.0013
20 0.0116 nan 0.0500 0.0005
40 0.0041 nan 0.0500 0.0001
60 0.0015 nan 0.0500 -0.0000
80 0.0008 nan 0.0500 0.0000
100 0.0004 nan 0.0500 0.0000
120 0.0002 nan 0.0500 -0.0000
140 0.0001 nan 0.0500 -0.0000
160 0.0001 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 0.0000
- Fold01: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold01: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0418 nan 0.0500 0.0022
2 0.0401 nan 0.0500 0.0002
3 0.0377 nan 0.0500 0.0023
4 0.0363 nan 0.0500 0.0007
5 0.0346 nan 0.0500 0.0014
6 0.0332 nan 0.0500 0.0017
7 0.0316 nan 0.0500 0.0012
8 0.0303 nan 0.0500 0.0011
9 0.0286 nan 0.0500 0.0014
10 0.0270 nan 0.0500 0.0003
20 0.0170 nan 0.0500 0.0002
40 0.0087 nan 0.0500 0.0001
60 0.0058 nan 0.0500 -0.0000
80 0.0043 nan 0.0500 -0.0000
100 0.0032 nan 0.0500 -0.0000
120 0.0023 nan 0.0500 0.0000
140 0.0015 nan 0.0500 0.0000
160 0.0011 nan 0.0500 0.0000
180 0.0008 nan 0.0500 -0.0000
200 0.0006 nan 0.0500 -0.0000
- Fold01: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold01: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0432 nan 0.0500 -0.0007
2 0.0400 nan 0.0500 0.0035
3 0.0361 nan 0.0500 0.0026
4 0.0337 nan 0.0500 0.0026
5 0.0305 nan 0.0500 0.0024
6 0.0277 nan 0.0500 0.0022
7 0.0253 nan 0.0500 0.0023
8 0.0240 nan 0.0500 0.0004
9 0.0219 nan 0.0500 0.0011
10 0.0206 nan 0.0500 0.0015
20 0.0101 nan 0.0500 0.0006
40 0.0032 nan 0.0500 0.0001
60 0.0010 nan 0.0500 -0.0000
80 0.0005 nan 0.0500 -0.0000
100 0.0002 nan 0.0500 -0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0000 nan 0.0500 0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold01: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold01: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0413 nan 0.0500 0.0039
2 0.0382 nan 0.0500 0.0032
3 0.0358 nan 0.0500 0.0020
4 0.0331 nan 0.0500 0.0025
5 0.0313 nan 0.0500 0.0017
6 0.0298 nan 0.0500 0.0007
7 0.0275 nan 0.0500 0.0019
8 0.0246 nan 0.0500 0.0023
9 0.0227 nan 0.0500 0.0004
10 0.0208 nan 0.0500 0.0015
20 0.0120 nan 0.0500 0.0008
40 0.0038 nan 0.0500 0.0000
60 0.0015 nan 0.0500 0.0000
80 0.0009 nan 0.0500 -0.0000
100 0.0005 nan 0.0500 0.0000
120 0.0003 nan 0.0500 -0.0000
140 0.0002 nan 0.0500 -0.0000
160 0.0001 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold01: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold01: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0416 nan 0.0500 0.0022
2 0.0397 nan 0.0500 0.0012
3 0.0380 nan 0.0500 0.0014
4 0.0353 nan 0.0500 0.0024
5 0.0334 nan 0.0500 0.0006
6 0.0312 nan 0.0500 0.0014
7 0.0296 nan 0.0500 0.0007
8 0.0281 nan 0.0500 0.0000
9 0.0262 nan 0.0500 0.0018
10 0.0243 nan 0.0500 0.0006
20 0.0155 nan 0.0500 0.0005
40 0.0087 nan 0.0500 -0.0001
60 0.0051 nan 0.0500 0.0000
80 0.0039 nan 0.0500 -0.0000
100 0.0028 nan 0.0500 -0.0000
120 0.0018 nan 0.0500 0.0000
140 0.0013 nan 0.0500 0.0000
160 0.0009 nan 0.0500 0.0000
180 0.0006 nan 0.0500 0.0000
200 0.0005 nan 0.0500 -0.0000
- Fold01: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold01: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0409 nan 0.1000 0.0019
2 0.0366 nan 0.1000 0.0032
3 0.0344 nan 0.1000 -0.0012
4 0.0299 nan 0.1000 0.0026
5 0.0277 nan 0.1000 0.0003
6 0.0241 nan 0.1000 0.0031
7 0.0223 nan 0.1000 0.0001
8 0.0211 nan 0.1000 -0.0003
9 0.0183 nan 0.1000 0.0025
10 0.0163 nan 0.1000 0.0019
20 0.0072 nan 0.1000 0.0005
40 0.0021 nan 0.1000 -0.0000
60 0.0008 nan 0.1000 0.0000
80 0.0003 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0001 nan 0.1000 0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold01: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold01: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0400 nan 0.1000 0.0030
2 0.0353 nan 0.1000 0.0033
3 0.0312 nan 0.1000 0.0039
4 0.0273 nan 0.1000 0.0030
5 0.0251 nan 0.1000 0.0021
6 0.0231 nan 0.1000 0.0008
7 0.0203 nan 0.1000 0.0026
8 0.0186 nan 0.1000 0.0019
9 0.0169 nan 0.1000 0.0017
10 0.0157 nan 0.1000 0.0013
20 0.0084 nan 0.1000 -0.0001
40 0.0023 nan 0.1000 0.0002
60 0.0007 nan 0.1000 0.0000
80 0.0003 nan 0.1000 -0.0000
100 0.0002 nan 0.1000 -0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold01: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold01: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0402 nan 0.1000 0.0037
2 0.0357 nan 0.1000 0.0041
3 0.0307 nan 0.1000 0.0032
4 0.0273 nan 0.1000 0.0030
5 0.0250 nan 0.1000 0.0003
6 0.0227 nan 0.1000 0.0022
7 0.0200 nan 0.1000 0.0019
8 0.0193 nan 0.1000 -0.0006
9 0.0172 nan 0.1000 0.0004
10 0.0160 nan 0.1000 0.0006
20 0.0083 nan 0.1000 0.0006
40 0.0032 nan 0.1000 0.0001
60 0.0016 nan 0.1000 -0.0000
80 0.0008 nan 0.1000 -0.0000
100 0.0005 nan 0.1000 -0.0000
120 0.0003 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 0.0000
180 0.0001 nan 0.1000 0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold01: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold01: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0368 nan 0.1000 0.0068
2 0.0305 nan 0.1000 0.0041
3 0.0271 nan 0.1000 0.0030
4 0.0238 nan 0.1000 0.0033
5 0.0211 nan 0.1000 -0.0002
6 0.0176 nan 0.1000 0.0030
7 0.0152 nan 0.1000 0.0020
8 0.0131 nan 0.1000 0.0013
9 0.0113 nan 0.1000 0.0017
10 0.0098 nan 0.1000 0.0005
20 0.0039 nan 0.1000 0.0003
40 0.0006 nan 0.1000 0.0000
60 0.0002 nan 0.1000 0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold01: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold01: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0395 nan 0.1000 0.0040
2 0.0330 nan 0.1000 0.0055
3 0.0295 nan 0.1000 0.0043
4 0.0251 nan 0.1000 0.0030
5 0.0213 nan 0.1000 0.0017
6 0.0184 nan 0.1000 0.0020
7 0.0159 nan 0.1000 0.0018
8 0.0143 nan 0.1000 0.0010
9 0.0128 nan 0.1000 0.0003
10 0.0117 nan 0.1000 0.0009
20 0.0039 nan 0.1000 0.0001
40 0.0008 nan 0.1000 0.0000
60 0.0002 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold01: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold01: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0389 nan 0.1000 0.0045
2 0.0360 nan 0.1000 0.0018
3 0.0325 nan 0.1000 0.0029
4 0.0286 nan 0.1000 0.0037
5 0.0253 nan 0.1000 0.0011
6 0.0223 nan 0.1000 0.0012
7 0.0205 nan 0.1000 0.0010
8 0.0180 nan 0.1000 0.0011
9 0.0165 nan 0.1000 0.0012
10 0.0152 nan 0.1000 0.0007
20 0.0076 nan 0.1000 0.0000
40 0.0030 nan 0.1000 0.0001
60 0.0011 nan 0.1000 0.0000
80 0.0006 nan 0.1000 -0.0000
100 0.0003 nan 0.1000 -0.0000
120 0.0002 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 0.0000
160 0.0001 nan 0.1000 0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold01: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold01: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0375 nan 0.1000 0.0051
2 0.0326 nan 0.1000 0.0036
3 0.0269 nan 0.1000 0.0047
4 0.0224 nan 0.1000 0.0039
5 0.0186 nan 0.1000 0.0022
6 0.0163 nan 0.1000 0.0023
7 0.0146 nan 0.1000 0.0006
8 0.0125 nan 0.1000 0.0015
9 0.0113 nan 0.1000 0.0012
10 0.0105 nan 0.1000 -0.0004
20 0.0032 nan 0.1000 0.0004
40 0.0005 nan 0.1000 -0.0000
60 0.0001 nan 0.1000 -0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 0.0000
180 0.0000 nan 0.1000 0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold01: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold01: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0353 nan 0.1000 0.0049
2 0.0304 nan 0.1000 0.0023
3 0.0257 nan 0.1000 0.0023
4 0.0230 nan 0.1000 0.0011
5 0.0200 nan 0.1000 0.0011
6 0.0168 nan 0.1000 0.0021
7 0.0143 nan 0.1000 0.0018
8 0.0134 nan 0.1000 0.0000
9 0.0121 nan 0.1000 0.0009
10 0.0106 nan 0.1000 0.0013
20 0.0045 nan 0.1000 -0.0003
40 0.0013 nan 0.1000 -0.0001
60 0.0003 nan 0.1000 0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 0.0000
120 0.0000 nan 0.1000 0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold01: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold01: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0391 nan 0.1000 0.0054
2 0.0350 nan 0.1000 0.0031
3 0.0309 nan 0.1000 0.0036
4 0.0288 nan 0.1000 0.0015
5 0.0258 nan 0.1000 0.0020
6 0.0237 nan 0.1000 0.0015
7 0.0218 nan 0.1000 0.0013
8 0.0199 nan 0.1000 0.0004
9 0.0178 nan 0.1000 0.0010
10 0.0170 nan 0.1000 -0.0007
20 0.0086 nan 0.1000 0.0003
40 0.0029 nan 0.1000 0.0001
60 0.0013 nan 0.1000 0.0000
80 0.0007 nan 0.1000 0.0000
100 0.0003 nan 0.1000 -0.0000
120 0.0002 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold01: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold02: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0433 nan 0.0100 0.0004
2 0.0430 nan 0.0100 0.0002
3 0.0425 nan 0.0100 0.0004
4 0.0418 nan 0.0100 0.0007
5 0.0414 nan 0.0100 0.0003
6 0.0408 nan 0.0100 0.0005
7 0.0402 nan 0.0100 0.0006
8 0.0397 nan 0.0100 0.0005
9 0.0392 nan 0.0100 0.0001
10 0.0388 nan 0.0100 0.0001
20 0.0344 nan 0.0100 0.0003
40 0.0268 nan 0.0100 0.0002
60 0.0222 nan 0.0100 0.0003
80 0.0181 nan 0.0100 0.0001
100 0.0147 nan 0.0100 0.0002
120 0.0120 nan 0.0100 0.0001
140 0.0101 nan 0.0100 0.0001
160 0.0085 nan 0.0100 0.0000
180 0.0073 nan 0.0100 0.0001
200 0.0063 nan 0.0100 -0.0000
- Fold02: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold02: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0431 nan 0.0100 0.0006
2 0.0425 nan 0.0100 0.0007
3 0.0419 nan 0.0100 0.0006
4 0.0415 nan 0.0100 0.0004
5 0.0410 nan 0.0100 0.0005
6 0.0406 nan 0.0100 0.0002
7 0.0403 nan 0.0100 -0.0000
8 0.0398 nan 0.0100 0.0005
9 0.0392 nan 0.0100 0.0005
10 0.0386 nan 0.0100 0.0005
20 0.0351 nan 0.0100 0.0001
40 0.0275 nan 0.0100 0.0003
60 0.0220 nan 0.0100 0.0001
80 0.0178 nan 0.0100 0.0001
100 0.0147 nan 0.0100 0.0001
120 0.0124 nan 0.0100 0.0001
140 0.0103 nan 0.0100 0.0000
160 0.0087 nan 0.0100 0.0001
180 0.0076 nan 0.0100 0.0000
200 0.0065 nan 0.0100 -0.0000
- Fold02: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold02: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0432 nan 0.0100 0.0005
2 0.0425 nan 0.0100 0.0006
3 0.0419 nan 0.0100 0.0005
4 0.0413 nan 0.0100 0.0006
5 0.0409 nan 0.0100 0.0001
6 0.0406 nan 0.0100 -0.0000
7 0.0402 nan 0.0100 0.0004
8 0.0396 nan 0.0100 0.0005
9 0.0393 nan 0.0100 0.0003
10 0.0388 nan 0.0100 0.0004
20 0.0343 nan 0.0100 0.0005
40 0.0277 nan 0.0100 0.0003
60 0.0226 nan 0.0100 0.0001
80 0.0186 nan 0.0100 0.0001
100 0.0155 nan 0.0100 0.0001
120 0.0132 nan 0.0100 0.0001
140 0.0115 nan 0.0100 0.0000
160 0.0101 nan 0.0100 -0.0001
180 0.0089 nan 0.0100 -0.0000
200 0.0080 nan 0.0100 0.0000
- Fold02: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold02: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0434 nan 0.0100 0.0001
2 0.0430 nan 0.0100 -0.0000
3 0.0424 nan 0.0100 0.0006
4 0.0417 nan 0.0100 0.0004
5 0.0413 nan 0.0100 0.0003
6 0.0408 nan 0.0100 0.0005
7 0.0405 nan 0.0100 0.0001
8 0.0401 nan 0.0100 0.0005
9 0.0393 nan 0.0100 0.0008
10 0.0387 nan 0.0100 0.0004
20 0.0337 nan 0.0100 0.0005
40 0.0259 nan 0.0100 0.0004
60 0.0198 nan 0.0100 0.0001
80 0.0152 nan 0.0100 0.0000
100 0.0117 nan 0.0100 0.0001
120 0.0095 nan 0.0100 0.0000
140 0.0076 nan 0.0100 0.0001
160 0.0062 nan 0.0100 0.0000
180 0.0050 nan 0.0100 0.0000
200 0.0040 nan 0.0100 0.0000
- Fold02: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold02: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0430 nan 0.0100 0.0007
2 0.0425 nan 0.0100 0.0003
3 0.0417 nan 0.0100 0.0009
4 0.0415 nan 0.0100 0.0000
5 0.0410 nan 0.0100 0.0005
6 0.0403 nan 0.0100 0.0004
7 0.0399 nan 0.0100 0.0002
8 0.0393 nan 0.0100 0.0006
9 0.0387 nan 0.0100 0.0004
10 0.0381 nan 0.0100 0.0006
20 0.0333 nan 0.0100 0.0003
40 0.0252 nan 0.0100 0.0002
60 0.0204 nan 0.0100 0.0002
80 0.0160 nan 0.0100 0.0001
100 0.0127 nan 0.0100 0.0001
120 0.0100 nan 0.0100 0.0001
140 0.0081 nan 0.0100 0.0001
160 0.0066 nan 0.0100 0.0001
180 0.0054 nan 0.0100 0.0001
200 0.0045 nan 0.0100 0.0000
- Fold02: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold02: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0432 nan 0.0100 0.0006
2 0.0428 nan 0.0100 0.0002
3 0.0422 nan 0.0100 0.0004
4 0.0417 nan 0.0100 0.0005
5 0.0411 nan 0.0100 0.0006
6 0.0404 nan 0.0100 0.0005
7 0.0400 nan 0.0100 0.0003
8 0.0396 nan 0.0100 0.0004
9 0.0392 nan 0.0100 0.0001
10 0.0386 nan 0.0100 0.0005
20 0.0341 nan 0.0100 0.0004
40 0.0274 nan 0.0100 0.0001
60 0.0223 nan 0.0100 0.0003
80 0.0186 nan 0.0100 0.0002
100 0.0158 nan 0.0100 0.0001
120 0.0136 nan 0.0100 0.0001
140 0.0117 nan 0.0100 0.0000
160 0.0102 nan 0.0100 -0.0000
180 0.0090 nan 0.0100 0.0000
200 0.0081 nan 0.0100 0.0000
- Fold02: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold02: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0431 nan 0.0100 0.0007
2 0.0422 nan 0.0100 0.0006
3 0.0415 nan 0.0100 0.0008
4 0.0408 nan 0.0100 0.0004
5 0.0404 nan 0.0100 0.0002
6 0.0397 nan 0.0100 0.0006
7 0.0391 nan 0.0100 0.0005
8 0.0386 nan 0.0100 0.0004
9 0.0379 nan 0.0100 0.0006
10 0.0375 nan 0.0100 0.0003
20 0.0322 nan 0.0100 0.0003
40 0.0238 nan 0.0100 0.0003
60 0.0178 nan 0.0100 0.0002
80 0.0134 nan 0.0100 0.0001
100 0.0102 nan 0.0100 0.0001
120 0.0077 nan 0.0100 0.0001
140 0.0060 nan 0.0100 0.0001
160 0.0046 nan 0.0100 -0.0000
180 0.0037 nan 0.0100 0.0000
200 0.0030 nan 0.0100 0.0000
- Fold02: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold02: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0431 nan 0.0100 0.0007
2 0.0425 nan 0.0100 0.0006
3 0.0418 nan 0.0100 0.0006
4 0.0412 nan 0.0100 0.0002
5 0.0407 nan 0.0100 0.0004
6 0.0401 nan 0.0100 0.0003
7 0.0396 nan 0.0100 0.0003
8 0.0392 nan 0.0100 0.0001
9 0.0386 nan 0.0100 0.0006
10 0.0379 nan 0.0100 0.0005
20 0.0331 nan 0.0100 0.0003
40 0.0253 nan 0.0100 0.0003
60 0.0198 nan 0.0100 0.0003
80 0.0155 nan 0.0100 0.0002
100 0.0124 nan 0.0100 0.0002
120 0.0098 nan 0.0100 0.0001
140 0.0079 nan 0.0100 0.0000
160 0.0064 nan 0.0100 0.0000
180 0.0053 nan 0.0100 0.0001
200 0.0044 nan 0.0100 0.0000
- Fold02: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold02: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0432 nan 0.0100 0.0003
2 0.0431 nan 0.0100 -0.0002
3 0.0423 nan 0.0100 0.0005
4 0.0417 nan 0.0100 0.0006
5 0.0412 nan 0.0100 0.0004
6 0.0406 nan 0.0100 0.0006
7 0.0403 nan 0.0100 0.0002
8 0.0400 nan 0.0100 0.0003
9 0.0395 nan 0.0100 0.0004
10 0.0389 nan 0.0100 0.0004
20 0.0345 nan 0.0100 0.0003
40 0.0277 nan 0.0100 0.0003
60 0.0227 nan 0.0100 -0.0001
80 0.0186 nan 0.0100 0.0000
100 0.0159 nan 0.0100 -0.0000
120 0.0136 nan 0.0100 -0.0001
140 0.0118 nan 0.0100 -0.0000
160 0.0100 nan 0.0100 0.0000
180 0.0088 nan 0.0100 -0.0000
200 0.0079 nan 0.0100 0.0000
- Fold02: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold02: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0412 nan 0.0500 0.0021
2 0.0383 nan 0.0500 0.0024
3 0.0352 nan 0.0500 0.0026
4 0.0324 nan 0.0500 0.0023
5 0.0312 nan 0.0500 0.0002
6 0.0297 nan 0.0500 0.0014
7 0.0281 nan 0.0500 0.0011
8 0.0264 nan 0.0500 0.0010
9 0.0260 nan 0.0500 -0.0006
10 0.0244 nan 0.0500 0.0017
20 0.0134 nan 0.0500 0.0003
40 0.0063 nan 0.0500 -0.0000
60 0.0030 nan 0.0500 -0.0001
80 0.0017 nan 0.0500 0.0000
100 0.0010 nan 0.0500 -0.0000
120 0.0005 nan 0.0500 -0.0000
140 0.0003 nan 0.0500 0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold02: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold02: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0425 nan 0.0500 -0.0004
2 0.0402 nan 0.0500 0.0023
3 0.0374 nan 0.0500 0.0021
4 0.0352 nan 0.0500 0.0016
5 0.0342 nan 0.0500 0.0005
6 0.0323 nan 0.0500 0.0016
7 0.0302 nan 0.0500 0.0020
8 0.0283 nan 0.0500 0.0015
9 0.0270 nan 0.0500 0.0011
10 0.0253 nan 0.0500 0.0010
20 0.0147 nan 0.0500 0.0003
40 0.0059 nan 0.0500 0.0002
60 0.0029 nan 0.0500 0.0001
80 0.0019 nan 0.0500 -0.0000
100 0.0013 nan 0.0500 -0.0000
120 0.0008 nan 0.0500 0.0000
140 0.0005 nan 0.0500 0.0000
160 0.0004 nan 0.0500 -0.0000
180 0.0002 nan 0.0500 0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold02: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold02: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0416 nan 0.0500 0.0020
2 0.0389 nan 0.0500 0.0023
3 0.0363 nan 0.0500 0.0027
4 0.0344 nan 0.0500 0.0018
5 0.0336 nan 0.0500 0.0002
6 0.0320 nan 0.0500 0.0020
7 0.0305 nan 0.0500 0.0009
8 0.0296 nan 0.0500 -0.0003
9 0.0278 nan 0.0500 0.0003
10 0.0265 nan 0.0500 0.0001
20 0.0160 nan 0.0500 0.0004
40 0.0077 nan 0.0500 0.0001
60 0.0043 nan 0.0500 0.0000
80 0.0029 nan 0.0500 0.0000
100 0.0019 nan 0.0500 -0.0000
120 0.0013 nan 0.0500 -0.0000
140 0.0009 nan 0.0500 -0.0000
160 0.0007 nan 0.0500 0.0000
180 0.0005 nan 0.0500 -0.0000
200 0.0004 nan 0.0500 -0.0000
- Fold02: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold02: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0420 nan 0.0500 0.0004
2 0.0387 nan 0.0500 0.0022
3 0.0361 nan 0.0500 0.0023
4 0.0329 nan 0.0500 0.0032
5 0.0304 nan 0.0500 0.0023
6 0.0288 nan 0.0500 0.0011
7 0.0264 nan 0.0500 0.0014
8 0.0239 nan 0.0500 0.0025
9 0.0224 nan 0.0500 0.0012
10 0.0209 nan 0.0500 0.0015
20 0.0119 nan 0.0500 0.0007
40 0.0041 nan 0.0500 0.0003
60 0.0016 nan 0.0500 -0.0000
80 0.0006 nan 0.0500 0.0000
100 0.0003 nan 0.0500 -0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0001 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold02: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold02: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0399 nan 0.0500 0.0030
2 0.0371 nan 0.0500 0.0029
3 0.0349 nan 0.0500 0.0019
4 0.0325 nan 0.0500 0.0024
5 0.0295 nan 0.0500 0.0023
6 0.0275 nan 0.0500 0.0020
7 0.0262 nan 0.0500 0.0000
8 0.0248 nan 0.0500 0.0012
9 0.0228 nan 0.0500 0.0017
10 0.0215 nan 0.0500 0.0014
20 0.0122 nan 0.0500 0.0001
40 0.0045 nan 0.0500 0.0002
60 0.0024 nan 0.0500 0.0000
80 0.0013 nan 0.0500 0.0000
100 0.0007 nan 0.0500 0.0000
120 0.0004 nan 0.0500 -0.0000
140 0.0003 nan 0.0500 0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold02: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold02: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0432 nan 0.0500 -0.0008
2 0.0423 nan 0.0500 -0.0001
3 0.0394 nan 0.0500 0.0027
4 0.0373 nan 0.0500 0.0016
5 0.0358 nan 0.0500 0.0005
6 0.0342 nan 0.0500 0.0007
7 0.0325 nan 0.0500 0.0013
8 0.0306 nan 0.0500 0.0019
9 0.0284 nan 0.0500 0.0018
10 0.0265 nan 0.0500 0.0014
20 0.0166 nan 0.0500 0.0008
40 0.0087 nan 0.0500 0.0002
60 0.0060 nan 0.0500 -0.0000
80 0.0039 nan 0.0500 0.0001
100 0.0026 nan 0.0500 0.0000
120 0.0017 nan 0.0500 0.0000
140 0.0012 nan 0.0500 0.0000
160 0.0009 nan 0.0500 -0.0000
180 0.0007 nan 0.0500 0.0000
200 0.0005 nan 0.0500 0.0000
- Fold02: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold02: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0419 nan 0.0500 0.0014
2 0.0395 nan 0.0500 0.0016
3 0.0366 nan 0.0500 0.0018
4 0.0330 nan 0.0500 0.0021
5 0.0307 nan 0.0500 0.0018
6 0.0281 nan 0.0500 0.0023
7 0.0260 nan 0.0500 0.0019
8 0.0248 nan 0.0500 0.0008
9 0.0224 nan 0.0500 0.0021
10 0.0207 nan 0.0500 0.0016
20 0.0105 nan 0.0500 0.0006
40 0.0030 nan 0.0500 0.0000
60 0.0014 nan 0.0500 -0.0000
80 0.0006 nan 0.0500 -0.0000
100 0.0002 nan 0.0500 -0.0000
120 0.0001 nan 0.0500 0.0000
140 0.0001 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold02: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold02: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0414 nan 0.0500 0.0010
2 0.0383 nan 0.0500 0.0014
3 0.0365 nan 0.0500 0.0009
4 0.0335 nan 0.0500 0.0028
5 0.0326 nan 0.0500 -0.0004
6 0.0301 nan 0.0500 0.0014
7 0.0288 nan 0.0500 0.0007
8 0.0272 nan 0.0500 0.0014
9 0.0245 nan 0.0500 0.0015
10 0.0223 nan 0.0500 0.0016
20 0.0129 nan 0.0500 -0.0000
40 0.0050 nan 0.0500 0.0002
60 0.0019 nan 0.0500 0.0000
80 0.0009 nan 0.0500 0.0000
100 0.0005 nan 0.0500 -0.0000
120 0.0003 nan 0.0500 -0.0000
140 0.0002 nan 0.0500 -0.0000
160 0.0001 nan 0.0500 0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold02: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold02: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0422 nan 0.0500 0.0006
2 0.0401 nan 0.0500 0.0014
3 0.0387 nan 0.0500 0.0006
4 0.0358 nan 0.0500 0.0020
5 0.0338 nan 0.0500 0.0013
6 0.0309 nan 0.0500 0.0014
7 0.0289 nan 0.0500 0.0016
8 0.0273 nan 0.0500 0.0011
9 0.0258 nan 0.0500 0.0014
10 0.0244 nan 0.0500 0.0005
20 0.0153 nan 0.0500 0.0006
40 0.0081 nan 0.0500 0.0002
60 0.0048 nan 0.0500 0.0001
80 0.0030 nan 0.0500 0.0000
100 0.0019 nan 0.0500 -0.0000
120 0.0012 nan 0.0500 -0.0000
140 0.0009 nan 0.0500 -0.0000
160 0.0006 nan 0.0500 -0.0000
180 0.0004 nan 0.0500 -0.0000
200 0.0003 nan 0.0500 -0.0000
- Fold02: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold02: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0377 nan 0.1000 0.0058
2 0.0346 nan 0.1000 0.0010
3 0.0316 nan 0.1000 0.0024
4 0.0273 nan 0.1000 0.0038
5 0.0247 nan 0.1000 0.0024
6 0.0218 nan 0.1000 0.0012
7 0.0200 nan 0.1000 0.0013
8 0.0174 nan 0.1000 0.0017
9 0.0160 nan 0.1000 0.0007
10 0.0141 nan 0.1000 0.0019
20 0.0059 nan 0.1000 0.0000
40 0.0018 nan 0.1000 -0.0001
60 0.0006 nan 0.1000 -0.0000
80 0.0002 nan 0.1000 0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold02: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold02: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0388 nan 0.1000 0.0048
2 0.0344 nan 0.1000 0.0041
3 0.0311 nan 0.1000 0.0031
4 0.0301 nan 0.1000 -0.0014
5 0.0272 nan 0.1000 0.0028
6 0.0247 nan 0.1000 0.0029
7 0.0219 nan 0.1000 0.0029
8 0.0198 nan 0.1000 -0.0005
9 0.0183 nan 0.1000 0.0012
10 0.0173 nan 0.1000 -0.0004
20 0.0080 nan 0.1000 0.0000
40 0.0030 nan 0.1000 -0.0001
60 0.0011 nan 0.1000 0.0000
80 0.0005 nan 0.1000 -0.0001
100 0.0003 nan 0.1000 -0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 0.0000
160 0.0000 nan 0.1000 0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold02: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold02: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0382 nan 0.1000 0.0057
2 0.0347 nan 0.1000 0.0028
3 0.0304 nan 0.1000 0.0041
4 0.0267 nan 0.1000 0.0029
5 0.0244 nan 0.1000 0.0015
6 0.0229 nan 0.1000 0.0021
7 0.0208 nan 0.1000 0.0016
8 0.0188 nan 0.1000 0.0018
9 0.0167 nan 0.1000 0.0013
10 0.0148 nan 0.1000 0.0010
20 0.0076 nan 0.1000 0.0003
40 0.0037 nan 0.1000 0.0002
60 0.0018 nan 0.1000 -0.0000
80 0.0010 nan 0.1000 -0.0001
100 0.0005 nan 0.1000 -0.0000
120 0.0003 nan 0.1000 0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold02: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold02: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0357 nan 0.1000 0.0079
2 0.0306 nan 0.1000 0.0040
3 0.0264 nan 0.1000 0.0030
4 0.0224 nan 0.1000 0.0017
5 0.0202 nan 0.1000 0.0020
6 0.0168 nan 0.1000 0.0027
7 0.0153 nan 0.1000 0.0005
8 0.0127 nan 0.1000 0.0030
9 0.0115 nan 0.1000 0.0008
10 0.0100 nan 0.1000 0.0006
20 0.0039 nan 0.1000 0.0005
40 0.0008 nan 0.1000 0.0000
60 0.0002 nan 0.1000 0.0000
80 0.0000 nan 0.1000 0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold02: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold02: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0379 nan 0.1000 0.0054
2 0.0334 nan 0.1000 0.0036
3 0.0301 nan 0.1000 0.0007
4 0.0254 nan 0.1000 0.0046
5 0.0220 nan 0.1000 0.0017
6 0.0185 nan 0.1000 0.0025
7 0.0165 nan 0.1000 0.0018
8 0.0148 nan 0.1000 0.0006
9 0.0122 nan 0.1000 0.0010
10 0.0106 nan 0.1000 0.0012
20 0.0039 nan 0.1000 -0.0003
40 0.0010 nan 0.1000 0.0000
60 0.0003 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold02: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold02: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0387 nan 0.1000 0.0057
2 0.0346 nan 0.1000 0.0030
3 0.0338 nan 0.1000 -0.0018
4 0.0301 nan 0.1000 0.0040
5 0.0266 nan 0.1000 0.0035
6 0.0249 nan 0.1000 0.0014
7 0.0220 nan 0.1000 0.0024
8 0.0206 nan 0.1000 0.0005
9 0.0186 nan 0.1000 0.0013
10 0.0173 nan 0.1000 0.0011
20 0.0096 nan 0.1000 -0.0001
40 0.0035 nan 0.1000 -0.0001
60 0.0018 nan 0.1000 0.0001
80 0.0010 nan 0.1000 -0.0000
100 0.0007 nan 0.1000 -0.0000
120 0.0004 nan 0.1000 0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold02: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold02: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0426 nan 0.1000 -0.0012
2 0.0361 nan 0.1000 0.0021
3 0.0313 nan 0.1000 0.0029
4 0.0278 nan 0.1000 0.0031
5 0.0247 nan 0.1000 0.0025
6 0.0218 nan 0.1000 0.0027
7 0.0193 nan 0.1000 0.0020
8 0.0175 nan 0.1000 0.0024
9 0.0159 nan 0.1000 0.0011
10 0.0143 nan 0.1000 0.0012
20 0.0039 nan 0.1000 0.0005
40 0.0006 nan 0.1000 -0.0000
60 0.0001 nan 0.1000 -0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold02: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold02: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0362 nan 0.1000 0.0045
2 0.0317 nan 0.1000 0.0042
3 0.0279 nan 0.1000 0.0019
4 0.0248 nan 0.1000 0.0023
5 0.0216 nan 0.1000 0.0027
6 0.0193 nan 0.1000 0.0017
7 0.0172 nan 0.1000 0.0005
8 0.0161 nan 0.1000 0.0007
9 0.0149 nan 0.1000 0.0010
10 0.0133 nan 0.1000 0.0015
20 0.0044 nan 0.1000 0.0001
40 0.0012 nan 0.1000 -0.0000
60 0.0004 nan 0.1000 -0.0000
80 0.0002 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold02: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold02: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0383 nan 0.1000 0.0048
2 0.0339 nan 0.1000 0.0037
3 0.0311 nan 0.1000 0.0003
4 0.0279 nan 0.1000 0.0022
5 0.0245 nan 0.1000 0.0030
6 0.0217 nan 0.1000 0.0016
7 0.0200 nan 0.1000 0.0013
8 0.0185 nan 0.1000 0.0009
9 0.0164 nan 0.1000 0.0009
10 0.0140 nan 0.1000 0.0008
20 0.0077 nan 0.1000 -0.0002
40 0.0034 nan 0.1000 -0.0001
60 0.0015 nan 0.1000 -0.0000
80 0.0008 nan 0.1000 -0.0000
100 0.0005 nan 0.1000 -0.0000
120 0.0004 nan 0.1000 0.0000
140 0.0003 nan 0.1000 -0.0000
160 0.0002 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold02: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold03: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0368 nan 0.0100 0.0005
2 0.0363 nan 0.0100 0.0005
3 0.0358 nan 0.0100 0.0004
4 0.0355 nan 0.0100 0.0002
5 0.0351 nan 0.0100 0.0003
6 0.0348 nan 0.0100 0.0001
7 0.0344 nan 0.0100 0.0001
8 0.0340 nan 0.0100 0.0004
9 0.0334 nan 0.0100 0.0005
10 0.0330 nan 0.0100 0.0002
20 0.0293 nan 0.0100 0.0003
40 0.0236 nan 0.0100 0.0002
60 0.0193 nan 0.0100 0.0002
80 0.0155 nan 0.0100 0.0003
100 0.0130 nan 0.0100 0.0001
120 0.0109 nan 0.0100 0.0001
140 0.0090 nan 0.0100 0.0000
160 0.0077 nan 0.0100 -0.0000
180 0.0065 nan 0.0100 0.0000
200 0.0056 nan 0.0100 0.0000
- Fold03: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold03: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0369 nan 0.0100 0.0005
2 0.0364 nan 0.0100 0.0004
3 0.0361 nan 0.0100 0.0002
4 0.0355 nan 0.0100 0.0004
5 0.0351 nan 0.0100 0.0004
6 0.0346 nan 0.0100 0.0003
7 0.0341 nan 0.0100 0.0004
8 0.0338 nan 0.0100 0.0002
9 0.0333 nan 0.0100 0.0004
10 0.0330 nan 0.0100 0.0002
20 0.0292 nan 0.0100 0.0004
40 0.0235 nan 0.0100 0.0003
60 0.0192 nan 0.0100 0.0001
80 0.0159 nan 0.0100 -0.0000
100 0.0132 nan 0.0100 0.0000
120 0.0111 nan 0.0100 0.0000
140 0.0092 nan 0.0100 0.0001
160 0.0079 nan 0.0100 0.0000
180 0.0069 nan 0.0100 0.0000
200 0.0059 nan 0.0100 0.0000
- Fold03: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold03: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0369 nan 0.0100 0.0004
2 0.0364 nan 0.0100 0.0005
3 0.0358 nan 0.0100 0.0005
4 0.0355 nan 0.0100 0.0003
5 0.0353 nan 0.0100 -0.0000
6 0.0350 nan 0.0100 0.0002
7 0.0346 nan 0.0100 0.0004
8 0.0341 nan 0.0100 0.0005
9 0.0336 nan 0.0100 0.0004
10 0.0331 nan 0.0100 0.0004
20 0.0293 nan 0.0100 0.0004
40 0.0234 nan 0.0100 0.0002
60 0.0188 nan 0.0100 0.0002
80 0.0153 nan 0.0100 0.0000
100 0.0129 nan 0.0100 0.0001
120 0.0111 nan 0.0100 0.0000
140 0.0097 nan 0.0100 0.0001
160 0.0085 nan 0.0100 0.0000
180 0.0075 nan 0.0100 0.0000
200 0.0068 nan 0.0100 0.0000
- Fold03: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold03: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0368 nan 0.0100 0.0002
2 0.0362 nan 0.0100 0.0007
3 0.0355 nan 0.0100 0.0005
4 0.0351 nan 0.0100 0.0002
5 0.0345 nan 0.0100 0.0004
6 0.0341 nan 0.0100 0.0001
7 0.0337 nan 0.0100 0.0002
8 0.0334 nan 0.0100 0.0000
9 0.0330 nan 0.0100 0.0003
10 0.0324 nan 0.0100 0.0003
20 0.0281 nan 0.0100 0.0004
40 0.0216 nan 0.0100 0.0002
60 0.0167 nan 0.0100 0.0000
80 0.0132 nan 0.0100 0.0001
100 0.0104 nan 0.0100 0.0001
120 0.0083 nan 0.0100 0.0000
140 0.0067 nan 0.0100 0.0000
160 0.0054 nan 0.0100 0.0000
180 0.0044 nan 0.0100 -0.0000
200 0.0037 nan 0.0100 0.0000
- Fold03: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold03: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0367 nan 0.0100 0.0006
2 0.0361 nan 0.0100 0.0006
3 0.0355 nan 0.0100 0.0002
4 0.0350 nan 0.0100 0.0002
5 0.0346 nan 0.0100 0.0004
6 0.0343 nan 0.0100 0.0002
7 0.0339 nan 0.0100 0.0002
8 0.0335 nan 0.0100 0.0004
9 0.0330 nan 0.0100 0.0002
10 0.0326 nan 0.0100 0.0004
20 0.0285 nan 0.0100 0.0003
40 0.0220 nan 0.0100 0.0001
60 0.0173 nan 0.0100 0.0003
80 0.0134 nan 0.0100 -0.0000
100 0.0108 nan 0.0100 0.0000
120 0.0088 nan 0.0100 0.0000
140 0.0071 nan 0.0100 0.0001
160 0.0057 nan 0.0100 0.0000
180 0.0048 nan 0.0100 0.0000
200 0.0040 nan 0.0100 0.0000
- Fold03: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold03: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0369 nan 0.0100 0.0004
2 0.0365 nan 0.0100 0.0002
3 0.0360 nan 0.0100 0.0005
4 0.0356 nan 0.0100 0.0004
5 0.0350 nan 0.0100 0.0005
6 0.0346 nan 0.0100 0.0004
7 0.0342 nan 0.0100 0.0005
8 0.0338 nan 0.0100 0.0003
9 0.0335 nan 0.0100 0.0004
10 0.0330 nan 0.0100 0.0003
20 0.0291 nan 0.0100 0.0002
40 0.0231 nan 0.0100 0.0001
60 0.0189 nan 0.0100 0.0001
80 0.0160 nan 0.0100 0.0001
100 0.0139 nan 0.0100 0.0000
120 0.0119 nan 0.0100 0.0001
140 0.0102 nan 0.0100 0.0000
160 0.0090 nan 0.0100 0.0000
180 0.0079 nan 0.0100 0.0000
200 0.0072 nan 0.0100 -0.0000
- Fold03: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold03: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0367 nan 0.0100 0.0007
2 0.0362 nan 0.0100 0.0003
3 0.0356 nan 0.0100 0.0004
4 0.0350 nan 0.0100 0.0006
5 0.0348 nan 0.0100 -0.0000
6 0.0343 nan 0.0100 0.0004
7 0.0340 nan 0.0100 0.0001
8 0.0336 nan 0.0100 0.0003
9 0.0332 nan 0.0100 0.0003
10 0.0326 nan 0.0100 0.0004
20 0.0285 nan 0.0100 0.0003
40 0.0216 nan 0.0100 0.0002
60 0.0162 nan 0.0100 0.0001
80 0.0124 nan 0.0100 0.0001
100 0.0096 nan 0.0100 -0.0000
120 0.0072 nan 0.0100 0.0001
140 0.0057 nan 0.0100 0.0000
160 0.0047 nan 0.0100 -0.0001
180 0.0037 nan 0.0100 0.0001
200 0.0029 nan 0.0100 -0.0000
- Fold03: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold03: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0369 nan 0.0100 0.0002
2 0.0362 nan 0.0100 0.0006
3 0.0357 nan 0.0100 0.0004
4 0.0352 nan 0.0100 0.0005
5 0.0348 nan 0.0100 0.0003
6 0.0343 nan 0.0100 0.0004
7 0.0338 nan 0.0100 0.0004
8 0.0333 nan 0.0100 0.0003
9 0.0328 nan 0.0100 0.0001
10 0.0323 nan 0.0100 0.0004
20 0.0283 nan 0.0100 0.0003
40 0.0217 nan 0.0100 0.0002
60 0.0170 nan 0.0100 0.0002
80 0.0133 nan 0.0100 0.0002
100 0.0105 nan 0.0100 0.0001
120 0.0087 nan 0.0100 0.0001
140 0.0070 nan 0.0100 0.0000
160 0.0058 nan 0.0100 -0.0000
180 0.0051 nan 0.0100 0.0000
200 0.0042 nan 0.0100 0.0000
- Fold03: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold03: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0371 nan 0.0100 -0.0000
2 0.0370 nan 0.0100 -0.0001
3 0.0365 nan 0.0100 0.0005
4 0.0361 nan 0.0100 0.0004
5 0.0357 nan 0.0100 0.0004
6 0.0353 nan 0.0100 0.0004
7 0.0348 nan 0.0100 0.0005
8 0.0343 nan 0.0100 0.0004
9 0.0342 nan 0.0100 -0.0002
10 0.0338 nan 0.0100 0.0003
20 0.0298 nan 0.0100 0.0002
40 0.0237 nan 0.0100 0.0003
60 0.0193 nan 0.0100 0.0001
80 0.0160 nan 0.0100 0.0000
100 0.0137 nan 0.0100 0.0001
120 0.0118 nan 0.0100 -0.0000
140 0.0103 nan 0.0100 0.0000
160 0.0092 nan 0.0100 -0.0001
180 0.0082 nan 0.0100 0.0000
200 0.0072 nan 0.0100 0.0000
- Fold03: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold03: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0352 nan 0.0500 0.0020
2 0.0322 nan 0.0500 0.0024
3 0.0304 nan 0.0500 0.0016
4 0.0287 nan 0.0500 0.0006
5 0.0268 nan 0.0500 0.0013
6 0.0256 nan 0.0500 0.0008
7 0.0241 nan 0.0500 0.0017
8 0.0228 nan 0.0500 0.0008
9 0.0214 nan 0.0500 0.0010
10 0.0205 nan 0.0500 0.0008
20 0.0124 nan 0.0500 0.0001
40 0.0051 nan 0.0500 0.0001
60 0.0024 nan 0.0500 0.0000
80 0.0015 nan 0.0500 -0.0001
100 0.0009 nan 0.0500 -0.0000
120 0.0005 nan 0.0500 0.0000
140 0.0003 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 0.0000
- Fold03: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold03: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0352 nan 0.0500 0.0025
2 0.0329 nan 0.0500 0.0017
3 0.0308 nan 0.0500 0.0016
4 0.0294 nan 0.0500 0.0010
5 0.0276 nan 0.0500 0.0006
6 0.0261 nan 0.0500 0.0006
7 0.0249 nan 0.0500 0.0007
8 0.0236 nan 0.0500 0.0005
9 0.0220 nan 0.0500 0.0013
10 0.0204 nan 0.0500 0.0010
20 0.0128 nan 0.0500 0.0006
40 0.0057 nan 0.0500 -0.0001
60 0.0029 nan 0.0500 -0.0000
80 0.0017 nan 0.0500 -0.0001
100 0.0011 nan 0.0500 -0.0000
120 0.0007 nan 0.0500 0.0000
140 0.0004 nan 0.0500 0.0000
160 0.0003 nan 0.0500 -0.0000
180 0.0002 nan 0.0500 0.0000
200 0.0002 nan 0.0500 -0.0000
- Fold03: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold03: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0361 nan 0.0500 0.0011
2 0.0351 nan 0.0500 0.0001
3 0.0325 nan 0.0500 0.0023
4 0.0308 nan 0.0500 0.0018
5 0.0289 nan 0.0500 0.0021
6 0.0269 nan 0.0500 0.0017
7 0.0257 nan 0.0500 0.0008
8 0.0242 nan 0.0500 0.0014
9 0.0232 nan 0.0500 0.0008
10 0.0216 nan 0.0500 0.0007
20 0.0139 nan 0.0500 0.0007
40 0.0075 nan 0.0500 -0.0001
60 0.0053 nan 0.0500 -0.0000
80 0.0038 nan 0.0500 0.0000
100 0.0029 nan 0.0500 -0.0000
120 0.0022 nan 0.0500 0.0000
140 0.0018 nan 0.0500 0.0000
160 0.0014 nan 0.0500 -0.0000
180 0.0011 nan 0.0500 -0.0000
200 0.0008 nan 0.0500 0.0000
- Fold03: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold03: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0337 nan 0.0500 0.0040
2 0.0310 nan 0.0500 0.0026
3 0.0298 nan 0.0500 0.0013
4 0.0272 nan 0.0500 0.0028
5 0.0256 nan 0.0500 0.0002
6 0.0235 nan 0.0500 0.0020
7 0.0223 nan 0.0500 0.0009
8 0.0206 nan 0.0500 0.0014
9 0.0199 nan 0.0500 0.0002
10 0.0188 nan 0.0500 0.0002
20 0.0103 nan 0.0500 0.0006
40 0.0035 nan 0.0500 -0.0000
60 0.0015 nan 0.0500 -0.0000
80 0.0006 nan 0.0500 -0.0000
100 0.0003 nan 0.0500 0.0000
120 0.0002 nan 0.0500 -0.0000
140 0.0001 nan 0.0500 0.0000
160 0.0000 nan 0.0500 0.0000
180 0.0000 nan 0.0500 0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold03: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold03: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0354 nan 0.0500 0.0018
2 0.0333 nan 0.0500 0.0020
3 0.0308 nan 0.0500 0.0011
4 0.0277 nan 0.0500 0.0025
5 0.0261 nan 0.0500 0.0014
6 0.0245 nan 0.0500 0.0015
7 0.0230 nan 0.0500 0.0017
8 0.0217 nan 0.0500 0.0010
9 0.0201 nan 0.0500 0.0015
10 0.0187 nan 0.0500 0.0005
20 0.0103 nan 0.0500 0.0005
40 0.0035 nan 0.0500 0.0001
60 0.0018 nan 0.0500 -0.0000
80 0.0009 nan 0.0500 0.0000
100 0.0005 nan 0.0500 0.0000
120 0.0003 nan 0.0500 -0.0000
140 0.0002 nan 0.0500 0.0000
160 0.0001 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold03: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold03: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0350 nan 0.0500 0.0021
2 0.0326 nan 0.0500 0.0020
3 0.0308 nan 0.0500 0.0018
4 0.0296 nan 0.0500 0.0007
5 0.0285 nan 0.0500 0.0007
6 0.0275 nan 0.0500 0.0003
7 0.0265 nan 0.0500 0.0010
8 0.0254 nan 0.0500 0.0008
9 0.0236 nan 0.0500 0.0013
10 0.0225 nan 0.0500 0.0009
20 0.0153 nan 0.0500 0.0007
40 0.0083 nan 0.0500 0.0002
60 0.0059 nan 0.0500 -0.0001
80 0.0040 nan 0.0500 0.0001
100 0.0030 nan 0.0500 -0.0001
120 0.0023 nan 0.0500 -0.0000
140 0.0017 nan 0.0500 -0.0000
160 0.0012 nan 0.0500 -0.0000
180 0.0009 nan 0.0500 -0.0000
200 0.0007 nan 0.0500 -0.0000
- Fold03: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold03: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0337 nan 0.0500 0.0033
2 0.0308 nan 0.0500 0.0029
3 0.0280 nan 0.0500 0.0025
4 0.0260 nan 0.0500 0.0007
5 0.0235 nan 0.0500 0.0019
6 0.0220 nan 0.0500 0.0006
7 0.0205 nan 0.0500 0.0014
8 0.0195 nan 0.0500 0.0003
9 0.0181 nan 0.0500 0.0012
10 0.0168 nan 0.0500 0.0011
20 0.0081 nan 0.0500 0.0007
40 0.0022 nan 0.0500 0.0001
60 0.0009 nan 0.0500 0.0000
80 0.0003 nan 0.0500 0.0000
100 0.0002 nan 0.0500 -0.0000
120 0.0001 nan 0.0500 0.0000
140 0.0000 nan 0.0500 0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold03: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold03: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0341 nan 0.0500 0.0027
2 0.0322 nan 0.0500 0.0017
3 0.0296 nan 0.0500 0.0010
4 0.0279 nan 0.0500 0.0017
5 0.0264 nan 0.0500 0.0013
6 0.0239 nan 0.0500 0.0010
7 0.0227 nan 0.0500 0.0013
8 0.0211 nan 0.0500 0.0002
9 0.0196 nan 0.0500 0.0013
10 0.0186 nan 0.0500 0.0000
20 0.0099 nan 0.0500 0.0005
40 0.0036 nan 0.0500 0.0002
60 0.0017 nan 0.0500 0.0000
80 0.0009 nan 0.0500 -0.0000
100 0.0005 nan 0.0500 0.0000
120 0.0003 nan 0.0500 -0.0000
140 0.0002 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 0.0000
- Fold03: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold03: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0352 nan 0.0500 0.0007
2 0.0332 nan 0.0500 0.0023
3 0.0313 nan 0.0500 0.0018
4 0.0294 nan 0.0500 0.0017
5 0.0276 nan 0.0500 0.0014
6 0.0268 nan 0.0500 -0.0002
7 0.0256 nan 0.0500 0.0011
8 0.0242 nan 0.0500 0.0014
9 0.0230 nan 0.0500 0.0007
10 0.0216 nan 0.0500 0.0011
20 0.0144 nan 0.0500 0.0007
40 0.0087 nan 0.0500 -0.0002
60 0.0048 nan 0.0500 0.0001
80 0.0036 nan 0.0500 -0.0000
100 0.0026 nan 0.0500 -0.0001
120 0.0018 nan 0.0500 -0.0000
140 0.0014 nan 0.0500 -0.0000
160 0.0011 nan 0.0500 -0.0000
180 0.0008 nan 0.0500 0.0000
200 0.0006 nan 0.0500 -0.0000
- Fold03: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold03: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0335 nan 0.1000 0.0044
2 0.0305 nan 0.1000 0.0028
3 0.0269 nan 0.1000 0.0029
4 0.0246 nan 0.1000 0.0022
5 0.0222 nan 0.1000 0.0013
6 0.0192 nan 0.1000 0.0024
7 0.0172 nan 0.1000 0.0020
8 0.0156 nan 0.1000 0.0002
9 0.0141 nan 0.1000 0.0006
10 0.0125 nan 0.1000 0.0012
20 0.0058 nan 0.1000 0.0002
40 0.0018 nan 0.1000 0.0001
60 0.0008 nan 0.1000 -0.0000
80 0.0003 nan 0.1000 -0.0000
100 0.0002 nan 0.1000 -0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold03: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold03: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0322 nan 0.1000 0.0038
2 0.0279 nan 0.1000 0.0043
3 0.0243 nan 0.1000 0.0031
4 0.0217 nan 0.1000 0.0026
5 0.0195 nan 0.1000 0.0021
6 0.0174 nan 0.1000 0.0019
7 0.0160 nan 0.1000 0.0014
8 0.0146 nan 0.1000 0.0009
9 0.0128 nan 0.1000 0.0005
10 0.0114 nan 0.1000 0.0009
20 0.0056 nan 0.1000 0.0001
40 0.0020 nan 0.1000 -0.0001
60 0.0008 nan 0.1000 -0.0001
80 0.0004 nan 0.1000 -0.0000
100 0.0002 nan 0.1000 0.0000
120 0.0001 nan 0.1000 0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold03: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold03: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0318 nan 0.1000 0.0046
2 0.0289 nan 0.1000 0.0027
3 0.0267 nan 0.1000 0.0017
4 0.0239 nan 0.1000 0.0026
5 0.0215 nan 0.1000 0.0002
6 0.0191 nan 0.1000 0.0019
7 0.0181 nan 0.1000 0.0003
8 0.0171 nan 0.1000 0.0004
9 0.0151 nan 0.1000 0.0011
10 0.0148 nan 0.1000 -0.0003
20 0.0082 nan 0.1000 -0.0005
40 0.0040 nan 0.1000 -0.0001
60 0.0025 nan 0.1000 0.0000
80 0.0015 nan 0.1000 0.0001
100 0.0010 nan 0.1000 -0.0001
120 0.0006 nan 0.1000 0.0000
140 0.0004 nan 0.1000 -0.0000
160 0.0003 nan 0.1000 0.0000
180 0.0002 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold03: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold03: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0324 nan 0.1000 0.0055
2 0.0281 nan 0.1000 0.0037
3 0.0229 nan 0.1000 0.0049
4 0.0198 nan 0.1000 0.0025
5 0.0176 nan 0.1000 0.0013
6 0.0156 nan 0.1000 0.0021
7 0.0139 nan 0.1000 0.0003
8 0.0118 nan 0.1000 0.0011
9 0.0102 nan 0.1000 0.0007
10 0.0085 nan 0.1000 0.0010
20 0.0025 nan 0.1000 0.0002
40 0.0003 nan 0.1000 -0.0000
60 0.0001 nan 0.1000 -0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold03: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold03: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0315 nan 0.1000 0.0054
2 0.0301 nan 0.1000 0.0001
3 0.0255 nan 0.1000 0.0031
4 0.0218 nan 0.1000 0.0037
5 0.0190 nan 0.1000 0.0020
6 0.0175 nan 0.1000 0.0003
7 0.0157 nan 0.1000 0.0013
8 0.0133 nan 0.1000 0.0013
9 0.0109 nan 0.1000 0.0010
10 0.0101 nan 0.1000 0.0010
20 0.0045 nan 0.1000 0.0000
40 0.0009 nan 0.1000 0.0001
60 0.0003 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 0.0000
140 0.0000 nan 0.1000 0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold03: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold03: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0318 nan 0.1000 0.0050
2 0.0284 nan 0.1000 0.0034
3 0.0252 nan 0.1000 0.0032
4 0.0215 nan 0.1000 0.0024
5 0.0197 nan 0.1000 0.0009
6 0.0181 nan 0.1000 0.0004
7 0.0168 nan 0.1000 -0.0004
8 0.0159 nan 0.1000 0.0003
9 0.0143 nan 0.1000 0.0007
10 0.0124 nan 0.1000 0.0013
20 0.0070 nan 0.1000 -0.0002
40 0.0034 nan 0.1000 0.0001
60 0.0018 nan 0.1000 -0.0000
80 0.0011 nan 0.1000 -0.0000
100 0.0006 nan 0.1000 0.0000
120 0.0004 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0002 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 0.0000
- Fold03: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold03: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0329 nan 0.1000 0.0029
2 0.0280 nan 0.1000 0.0032
3 0.0232 nan 0.1000 0.0034
4 0.0203 nan 0.1000 0.0017
5 0.0179 nan 0.1000 0.0006
6 0.0152 nan 0.1000 0.0036
7 0.0143 nan 0.1000 -0.0004
8 0.0123 nan 0.1000 0.0010
9 0.0101 nan 0.1000 0.0020
10 0.0086 nan 0.1000 0.0011
20 0.0031 nan 0.1000 0.0000
40 0.0004 nan 0.1000 -0.0000
60 0.0001 nan 0.1000 -0.0000
80 0.0000 nan 0.1000 0.0000
100 0.0000 nan 0.1000 0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold03: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold03: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0337 nan 0.1000 0.0019
2 0.0288 nan 0.1000 0.0047
3 0.0256 nan 0.1000 0.0027
4 0.0223 nan 0.1000 0.0025
5 0.0183 nan 0.1000 0.0029
6 0.0173 nan 0.1000 0.0001
7 0.0157 nan 0.1000 0.0016
8 0.0139 nan 0.1000 0.0016
9 0.0127 nan 0.1000 0.0005
10 0.0109 nan 0.1000 0.0010
20 0.0055 nan 0.1000 0.0000
40 0.0013 nan 0.1000 -0.0000
60 0.0005 nan 0.1000 0.0000
80 0.0003 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold03: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold03: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0334 nan 0.1000 0.0042
2 0.0305 nan 0.1000 -0.0012
3 0.0263 nan 0.1000 0.0039
4 0.0242 nan 0.1000 0.0017
5 0.0222 nan 0.1000 0.0010
6 0.0200 nan 0.1000 0.0023
7 0.0185 nan 0.1000 -0.0001
8 0.0167 nan 0.1000 0.0012
9 0.0151 nan 0.1000 0.0011
10 0.0140 nan 0.1000 0.0008
20 0.0076 nan 0.1000 0.0003
40 0.0033 nan 0.1000 -0.0000
60 0.0017 nan 0.1000 -0.0001
80 0.0010 nan 0.1000 -0.0000
100 0.0005 nan 0.1000 -0.0000
120 0.0003 nan 0.1000 0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold03: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold04: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0439 nan 0.0100 0.0001
2 0.0435 nan 0.0100 0.0001
3 0.0430 nan 0.0100 0.0002
4 0.0424 nan 0.0100 0.0006
5 0.0417 nan 0.0100 0.0006
6 0.0413 nan 0.0100 0.0003
7 0.0407 nan 0.0100 0.0004
8 0.0401 nan 0.0100 0.0006
9 0.0396 nan 0.0100 0.0002
10 0.0393 nan 0.0100 0.0002
20 0.0353 nan 0.0100 0.0002
40 0.0279 nan 0.0100 0.0002
60 0.0224 nan 0.0100 0.0003
80 0.0180 nan 0.0100 0.0002
100 0.0148 nan 0.0100 0.0001
120 0.0121 nan 0.0100 0.0000
140 0.0099 nan 0.0100 0.0000
160 0.0083 nan 0.0100 0.0000
180 0.0071 nan 0.0100 0.0000
200 0.0060 nan 0.0100 0.0000
- Fold04: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold04: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0436 nan 0.0100 0.0006
2 0.0430 nan 0.0100 0.0004
3 0.0424 nan 0.0100 0.0005
4 0.0418 nan 0.0100 0.0006
5 0.0414 nan 0.0100 0.0005
6 0.0410 nan 0.0100 0.0000
7 0.0405 nan 0.0100 0.0003
8 0.0400 nan 0.0100 0.0000
9 0.0395 nan 0.0100 0.0005
10 0.0390 nan 0.0100 0.0005
20 0.0345 nan 0.0100 0.0002
40 0.0274 nan 0.0100 -0.0000
60 0.0217 nan 0.0100 0.0001
80 0.0178 nan 0.0100 0.0000
100 0.0143 nan 0.0100 0.0001
120 0.0119 nan 0.0100 0.0001
140 0.0099 nan 0.0100 0.0000
160 0.0085 nan 0.0100 -0.0000
180 0.0072 nan 0.0100 0.0000
200 0.0060 nan 0.0100 -0.0000
- Fold04: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold04: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0438 nan 0.0100 0.0006
2 0.0433 nan 0.0100 0.0005
3 0.0428 nan 0.0100 0.0002
4 0.0423 nan 0.0100 0.0006
5 0.0420 nan 0.0100 0.0001
6 0.0418 nan 0.0100 0.0002
7 0.0414 nan 0.0100 0.0004
8 0.0408 nan 0.0100 0.0005
9 0.0403 nan 0.0100 0.0005
10 0.0399 nan 0.0100 0.0004
20 0.0356 nan 0.0100 0.0005
40 0.0286 nan 0.0100 0.0004
60 0.0227 nan 0.0100 0.0003
80 0.0187 nan 0.0100 -0.0001
100 0.0157 nan 0.0100 0.0001
120 0.0134 nan 0.0100 0.0001
140 0.0117 nan 0.0100 -0.0000
160 0.0102 nan 0.0100 0.0000
180 0.0091 nan 0.0100 0.0000
200 0.0081 nan 0.0100 0.0000
- Fold04: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold04: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0440 nan 0.0100 -0.0001
2 0.0434 nan 0.0100 0.0005
3 0.0427 nan 0.0100 0.0006
4 0.0420 nan 0.0100 0.0003
5 0.0414 nan 0.0100 0.0005
6 0.0409 nan 0.0100 0.0005
7 0.0405 nan 0.0100 0.0001
8 0.0399 nan 0.0100 0.0003
9 0.0391 nan 0.0100 0.0006
10 0.0384 nan 0.0100 0.0005
20 0.0339 nan 0.0100 0.0003
40 0.0255 nan 0.0100 0.0003
60 0.0194 nan 0.0100 0.0002
80 0.0149 nan 0.0100 0.0001
100 0.0115 nan 0.0100 0.0001
120 0.0092 nan 0.0100 0.0001
140 0.0072 nan 0.0100 0.0000
160 0.0058 nan 0.0100 0.0001
180 0.0046 nan 0.0100 0.0000
200 0.0037 nan 0.0100 0.0000
- Fold04: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold04: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0440 nan 0.0100 0.0003
2 0.0433 nan 0.0100 0.0006
3 0.0428 nan 0.0100 0.0005
4 0.0421 nan 0.0100 0.0004
5 0.0417 nan 0.0100 0.0001
6 0.0410 nan 0.0100 0.0005
7 0.0403 nan 0.0100 0.0007
8 0.0396 nan 0.0100 0.0006
9 0.0390 nan 0.0100 0.0004
10 0.0387 nan 0.0100 0.0001
20 0.0340 nan 0.0100 0.0002
40 0.0265 nan 0.0100 0.0004
60 0.0210 nan 0.0100 0.0002
80 0.0160 nan 0.0100 0.0002
100 0.0126 nan 0.0100 0.0001
120 0.0099 nan 0.0100 0.0001
140 0.0080 nan 0.0100 0.0000
160 0.0065 nan 0.0100 -0.0000
180 0.0053 nan 0.0100 0.0000
200 0.0044 nan 0.0100 0.0000
- Fold04: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold04: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0440 nan 0.0100 0.0003
2 0.0435 nan 0.0100 0.0003
3 0.0433 nan 0.0100 0.0000
4 0.0426 nan 0.0100 0.0006
5 0.0422 nan 0.0100 0.0003
6 0.0416 nan 0.0100 0.0005
7 0.0411 nan 0.0100 0.0004
8 0.0407 nan 0.0100 0.0003
9 0.0403 nan 0.0100 0.0003
10 0.0398 nan 0.0100 0.0003
20 0.0349 nan 0.0100 0.0004
40 0.0275 nan 0.0100 0.0001
60 0.0227 nan 0.0100 0.0001
80 0.0187 nan 0.0100 0.0002
100 0.0159 nan 0.0100 0.0002
120 0.0138 nan 0.0100 0.0000
140 0.0122 nan 0.0100 0.0000
160 0.0105 nan 0.0100 0.0001
180 0.0093 nan 0.0100 0.0000
200 0.0083 nan 0.0100 0.0000
- Fold04: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold04: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0437 nan 0.0100 0.0003
2 0.0434 nan 0.0100 0.0000
3 0.0427 nan 0.0100 0.0004
4 0.0420 nan 0.0100 0.0007
5 0.0414 nan 0.0100 0.0008
6 0.0406 nan 0.0100 0.0004
7 0.0399 nan 0.0100 0.0005
8 0.0394 nan 0.0100 0.0005
9 0.0390 nan 0.0100 0.0004
10 0.0384 nan 0.0100 0.0004
20 0.0331 nan 0.0100 0.0004
40 0.0248 nan 0.0100 0.0005
60 0.0188 nan 0.0100 0.0001
80 0.0146 nan 0.0100 -0.0000
100 0.0116 nan 0.0100 -0.0000
120 0.0090 nan 0.0100 0.0001
140 0.0071 nan 0.0100 0.0001
160 0.0055 nan 0.0100 0.0000
180 0.0042 nan 0.0100 -0.0000
200 0.0034 nan 0.0100 0.0000
- Fold04: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold04: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0436 nan 0.0100 0.0003
2 0.0432 nan 0.0100 0.0004
3 0.0427 nan 0.0100 0.0002
4 0.0420 nan 0.0100 0.0005
5 0.0415 nan 0.0100 0.0004
6 0.0407 nan 0.0100 0.0004
7 0.0402 nan 0.0100 0.0005
8 0.0394 nan 0.0100 0.0007
9 0.0388 nan 0.0100 0.0004
10 0.0382 nan 0.0100 0.0004
20 0.0329 nan 0.0100 0.0005
40 0.0252 nan 0.0100 0.0002
60 0.0191 nan 0.0100 0.0002
80 0.0148 nan 0.0100 0.0002
100 0.0119 nan 0.0100 0.0001
120 0.0093 nan 0.0100 0.0001
140 0.0076 nan 0.0100 0.0001
160 0.0062 nan 0.0100 0.0000
180 0.0050 nan 0.0100 0.0000
200 0.0042 nan 0.0100 -0.0000
- Fold04: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold04: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0438 nan 0.0100 0.0001
2 0.0431 nan 0.0100 0.0006
3 0.0426 nan 0.0100 0.0006
4 0.0423 nan 0.0100 0.0002
5 0.0421 nan 0.0100 -0.0001
6 0.0418 nan 0.0100 0.0002
7 0.0413 nan 0.0100 0.0005
8 0.0406 nan 0.0100 0.0006
9 0.0400 nan 0.0100 0.0004
10 0.0396 nan 0.0100 0.0003
20 0.0357 nan 0.0100 0.0001
40 0.0287 nan 0.0100 0.0003
60 0.0233 nan 0.0100 0.0001
80 0.0193 nan 0.0100 0.0002
100 0.0167 nan 0.0100 0.0002
120 0.0143 nan 0.0100 0.0001
140 0.0124 nan 0.0100 0.0001
160 0.0106 nan 0.0100 0.0001
180 0.0093 nan 0.0100 -0.0000
200 0.0082 nan 0.0100 0.0000
- Fold04: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold04: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0416 nan 0.0500 0.0023
2 0.0382 nan 0.0500 0.0032
3 0.0356 nan 0.0500 0.0023
4 0.0332 nan 0.0500 0.0016
5 0.0307 nan 0.0500 0.0021
6 0.0287 nan 0.0500 0.0014
7 0.0271 nan 0.0500 0.0006
8 0.0259 nan 0.0500 0.0014
9 0.0249 nan 0.0500 -0.0002
10 0.0241 nan 0.0500 0.0005
20 0.0144 nan 0.0500 0.0007
40 0.0060 nan 0.0500 -0.0000
60 0.0032 nan 0.0500 0.0000
80 0.0016 nan 0.0500 0.0000
100 0.0010 nan 0.0500 -0.0000
120 0.0006 nan 0.0500 0.0000
140 0.0004 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 0.0000
180 0.0002 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold04: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold04: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0423 nan 0.0500 0.0017
2 0.0387 nan 0.0500 0.0029
3 0.0361 nan 0.0500 0.0022
4 0.0342 nan 0.0500 0.0012
5 0.0323 nan 0.0500 0.0019
6 0.0304 nan 0.0500 0.0019
7 0.0290 nan 0.0500 0.0011
8 0.0276 nan 0.0500 0.0011
9 0.0257 nan 0.0500 0.0012
10 0.0248 nan 0.0500 0.0007
20 0.0159 nan 0.0500 0.0006
40 0.0067 nan 0.0500 0.0002
60 0.0032 nan 0.0500 0.0001
80 0.0018 nan 0.0500 0.0000
100 0.0011 nan 0.0500 0.0000
120 0.0006 nan 0.0500 0.0000
140 0.0004 nan 0.0500 -0.0000
160 0.0003 nan 0.0500 -0.0000
180 0.0002 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 0.0000
- Fold04: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold04: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0422 nan 0.0500 0.0027
2 0.0404 nan 0.0500 0.0019
3 0.0375 nan 0.0500 0.0027
4 0.0350 nan 0.0500 0.0017
5 0.0329 nan 0.0500 0.0015
6 0.0306 nan 0.0500 0.0022
7 0.0293 nan 0.0500 0.0009
8 0.0280 nan 0.0500 0.0006
9 0.0268 nan 0.0500 0.0009
10 0.0254 nan 0.0500 0.0013
20 0.0153 nan 0.0500 0.0003
40 0.0081 nan 0.0500 -0.0001
60 0.0048 nan 0.0500 0.0001
80 0.0031 nan 0.0500 -0.0001
100 0.0022 nan 0.0500 -0.0000
120 0.0015 nan 0.0500 -0.0000
140 0.0010 nan 0.0500 0.0000
160 0.0007 nan 0.0500 0.0000
180 0.0005 nan 0.0500 -0.0000
200 0.0004 nan 0.0500 -0.0000
- Fold04: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold04: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0411 nan 0.0500 0.0022
2 0.0379 nan 0.0500 0.0023
3 0.0356 nan 0.0500 0.0020
4 0.0326 nan 0.0500 0.0016
5 0.0303 nan 0.0500 0.0014
6 0.0283 nan 0.0500 0.0009
7 0.0262 nan 0.0500 0.0020
8 0.0258 nan 0.0500 -0.0010
9 0.0234 nan 0.0500 0.0017
10 0.0223 nan 0.0500 0.0011
20 0.0126 nan 0.0500 0.0001
40 0.0041 nan 0.0500 0.0004
60 0.0016 nan 0.0500 0.0000
80 0.0006 nan 0.0500 0.0000
100 0.0003 nan 0.0500 -0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0001 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold04: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold04: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0411 nan 0.0500 0.0020
2 0.0385 nan 0.0500 0.0021
3 0.0361 nan 0.0500 0.0025
4 0.0340 nan 0.0500 0.0014
5 0.0311 nan 0.0500 0.0026
6 0.0285 nan 0.0500 0.0011
7 0.0259 nan 0.0500 0.0018
8 0.0239 nan 0.0500 0.0014
9 0.0230 nan 0.0500 0.0002
10 0.0216 nan 0.0500 0.0014
20 0.0115 nan 0.0500 0.0001
40 0.0044 nan 0.0500 0.0000
60 0.0022 nan 0.0500 -0.0000
80 0.0010 nan 0.0500 -0.0000
100 0.0006 nan 0.0500 0.0000
120 0.0004 nan 0.0500 -0.0000
140 0.0002 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold04: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold04: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0414 nan 0.0500 0.0031
2 0.0394 nan 0.0500 0.0014
3 0.0377 nan 0.0500 0.0016
4 0.0353 nan 0.0500 0.0015
5 0.0330 nan 0.0500 0.0013
6 0.0315 nan 0.0500 0.0008
7 0.0309 nan 0.0500 -0.0003
8 0.0290 nan 0.0500 0.0020
9 0.0281 nan 0.0500 0.0008
10 0.0270 nan 0.0500 0.0008
20 0.0164 nan 0.0500 0.0007
40 0.0076 nan 0.0500 0.0003
60 0.0042 nan 0.0500 -0.0001
80 0.0025 nan 0.0500 -0.0001
100 0.0017 nan 0.0500 -0.0000
120 0.0013 nan 0.0500 -0.0000
140 0.0008 nan 0.0500 0.0000
160 0.0006 nan 0.0500 0.0000
180 0.0004 nan 0.0500 -0.0000
200 0.0003 nan 0.0500 -0.0000
- Fold04: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold04: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0409 nan 0.0500 0.0029
2 0.0381 nan 0.0500 0.0024
3 0.0349 nan 0.0500 0.0014
4 0.0341 nan 0.0500 -0.0003
5 0.0325 nan 0.0500 0.0015
6 0.0301 nan 0.0500 0.0015
7 0.0285 nan 0.0500 0.0011
8 0.0266 nan 0.0500 0.0024
9 0.0250 nan 0.0500 0.0000
10 0.0237 nan 0.0500 0.0008
20 0.0129 nan 0.0500 0.0008
40 0.0036 nan 0.0500 0.0002
60 0.0013 nan 0.0500 0.0000
80 0.0005 nan 0.0500 0.0000
100 0.0002 nan 0.0500 0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0000 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold04: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold04: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0411 nan 0.0500 0.0012
2 0.0377 nan 0.0500 0.0011
3 0.0350 nan 0.0500 0.0025
4 0.0325 nan 0.0500 0.0015
5 0.0303 nan 0.0500 0.0017
6 0.0280 nan 0.0500 0.0016
7 0.0263 nan 0.0500 0.0019
8 0.0245 nan 0.0500 0.0015
9 0.0242 nan 0.0500 -0.0009
10 0.0236 nan 0.0500 0.0002
20 0.0123 nan 0.0500 0.0004
40 0.0048 nan 0.0500 -0.0000
60 0.0017 nan 0.0500 -0.0000
80 0.0009 nan 0.0500 0.0000
100 0.0005 nan 0.0500 0.0000
120 0.0003 nan 0.0500 -0.0000
140 0.0002 nan 0.0500 -0.0000
160 0.0001 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold04: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold04: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0413 nan 0.0500 0.0030
2 0.0386 nan 0.0500 0.0016
3 0.0367 nan 0.0500 0.0018
4 0.0355 nan 0.0500 -0.0002
5 0.0339 nan 0.0500 0.0012
6 0.0316 nan 0.0500 0.0022
7 0.0300 nan 0.0500 0.0000
8 0.0286 nan 0.0500 0.0003
9 0.0273 nan 0.0500 0.0008
10 0.0263 nan 0.0500 0.0009
20 0.0165 nan 0.0500 0.0002
40 0.0090 nan 0.0500 0.0001
60 0.0054 nan 0.0500 0.0001
80 0.0038 nan 0.0500 -0.0001
100 0.0027 nan 0.0500 -0.0000
120 0.0020 nan 0.0500 0.0000
140 0.0014 nan 0.0500 0.0000
160 0.0011 nan 0.0500 -0.0000
180 0.0008 nan 0.0500 0.0000
200 0.0006 nan 0.0500 0.0000
- Fold04: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold04: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0380 nan 0.1000 0.0032
2 0.0322 nan 0.1000 0.0050
3 0.0289 nan 0.1000 0.0041
4 0.0272 nan 0.1000 0.0010
5 0.0239 nan 0.1000 0.0010
6 0.0205 nan 0.1000 0.0026
7 0.0184 nan 0.1000 0.0018
8 0.0156 nan 0.1000 0.0035
9 0.0136 nan 0.1000 0.0015
10 0.0127 nan 0.1000 0.0001
20 0.0046 nan 0.1000 0.0000
40 0.0013 nan 0.1000 0.0000
60 0.0005 nan 0.1000 0.0000
80 0.0002 nan 0.1000 0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold04: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold04: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0395 nan 0.1000 0.0052
2 0.0339 nan 0.1000 0.0036
3 0.0329 nan 0.1000 -0.0017
4 0.0291 nan 0.1000 0.0014
5 0.0261 nan 0.1000 0.0026
6 0.0238 nan 0.1000 0.0016
7 0.0218 nan 0.1000 0.0008
8 0.0200 nan 0.1000 0.0013
9 0.0182 nan 0.1000 0.0011
10 0.0168 nan 0.1000 0.0008
20 0.0074 nan 0.1000 0.0003
40 0.0024 nan 0.1000 0.0001
60 0.0010 nan 0.1000 -0.0001
80 0.0006 nan 0.1000 -0.0000
100 0.0003 nan 0.1000 0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold04: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold04: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0395 nan 0.1000 0.0036
2 0.0363 nan 0.1000 0.0034
3 0.0312 nan 0.1000 0.0048
4 0.0264 nan 0.1000 0.0034
5 0.0230 nan 0.1000 0.0017
6 0.0206 nan 0.1000 0.0022
7 0.0198 nan 0.1000 0.0008
8 0.0178 nan 0.1000 0.0018
9 0.0167 nan 0.1000 0.0005
10 0.0152 nan 0.1000 0.0013
20 0.0081 nan 0.1000 0.0004
40 0.0032 nan 0.1000 0.0001
60 0.0016 nan 0.1000 0.0000
80 0.0009 nan 0.1000 -0.0001
100 0.0006 nan 0.1000 -0.0000
120 0.0003 nan 0.1000 0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold04: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold04: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0375 nan 0.1000 0.0064
2 0.0325 nan 0.1000 0.0052
3 0.0271 nan 0.1000 0.0054
4 0.0223 nan 0.1000 0.0047
5 0.0191 nan 0.1000 0.0022
6 0.0179 nan 0.1000 0.0005
7 0.0177 nan 0.1000 -0.0020
8 0.0149 nan 0.1000 0.0023
9 0.0135 nan 0.1000 0.0013
10 0.0121 nan 0.1000 0.0013
20 0.0043 nan 0.1000 -0.0000
40 0.0009 nan 0.1000 -0.0000
60 0.0003 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold04: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold04: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0369 nan 0.1000 0.0066
2 0.0318 nan 0.1000 0.0042
3 0.0266 nan 0.1000 0.0043
4 0.0251 nan 0.1000 -0.0026
5 0.0213 nan 0.1000 0.0023
6 0.0195 nan 0.1000 0.0015
7 0.0170 nan 0.1000 0.0019
8 0.0150 nan 0.1000 0.0021
9 0.0130 nan 0.1000 0.0008
10 0.0109 nan 0.1000 0.0008
20 0.0043 nan 0.1000 0.0000
40 0.0009 nan 0.1000 0.0000
60 0.0003 nan 0.1000 0.0000
80 0.0001 nan 0.1000 0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold04: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold04: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0391 nan 0.1000 0.0061
2 0.0337 nan 0.1000 0.0046
3 0.0299 nan 0.1000 0.0038
4 0.0259 nan 0.1000 0.0033
5 0.0242 nan 0.1000 0.0014
6 0.0227 nan 0.1000 0.0012
7 0.0212 nan 0.1000 0.0013
8 0.0187 nan 0.1000 0.0004
9 0.0167 nan 0.1000 0.0009
10 0.0146 nan 0.1000 0.0008
20 0.0076 nan 0.1000 -0.0004
40 0.0036 nan 0.1000 0.0000
60 0.0016 nan 0.1000 -0.0001
80 0.0008 nan 0.1000 -0.0000
100 0.0004 nan 0.1000 -0.0000
120 0.0002 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold04: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold04: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0389 nan 0.1000 0.0050
2 0.0327 nan 0.1000 0.0048
3 0.0269 nan 0.1000 0.0040
4 0.0222 nan 0.1000 0.0045
5 0.0192 nan 0.1000 0.0010
6 0.0167 nan 0.1000 0.0023
7 0.0145 nan 0.1000 0.0016
8 0.0132 nan 0.1000 0.0014
9 0.0116 nan 0.1000 0.0005
10 0.0103 nan 0.1000 0.0009
20 0.0029 nan 0.1000 0.0003
40 0.0003 nan 0.1000 0.0000
60 0.0001 nan 0.1000 -0.0000
80 0.0000 nan 0.1000 0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold04: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold04: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0386 nan 0.1000 0.0051
2 0.0350 nan 0.1000 0.0045
3 0.0300 nan 0.1000 0.0031
4 0.0265 nan 0.1000 0.0035
5 0.0233 nan 0.1000 0.0034
6 0.0209 nan 0.1000 0.0021
7 0.0177 nan 0.1000 0.0023
8 0.0164 nan 0.1000 0.0017
9 0.0152 nan 0.1000 0.0015
10 0.0142 nan 0.1000 0.0005
20 0.0047 nan 0.1000 0.0004
40 0.0011 nan 0.1000 -0.0000
60 0.0004 nan 0.1000 0.0000
80 0.0002 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 0.0000
- Fold04: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold04: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0388 nan 0.1000 0.0059
2 0.0356 nan 0.1000 0.0021
3 0.0303 nan 0.1000 0.0041
4 0.0269 nan 0.1000 0.0016
5 0.0246 nan 0.1000 0.0013
6 0.0223 nan 0.1000 0.0025
7 0.0206 nan 0.1000 0.0014
8 0.0193 nan 0.1000 0.0013
9 0.0168 nan 0.1000 0.0014
10 0.0147 nan 0.1000 0.0008
20 0.0078 nan 0.1000 -0.0001
40 0.0034 nan 0.1000 -0.0000
60 0.0016 nan 0.1000 0.0000
80 0.0008 nan 0.1000 0.0000
100 0.0005 nan 0.1000 -0.0000
120 0.0003 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold04: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold05: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0430 nan 0.0100 0.0005
2 0.0425 nan 0.0100 0.0005
3 0.0421 nan 0.0100 0.0002
4 0.0414 nan 0.0100 0.0006
5 0.0410 nan 0.0100 0.0005
6 0.0405 nan 0.0100 0.0006
7 0.0401 nan 0.0100 0.0003
8 0.0396 nan 0.0100 0.0004
9 0.0391 nan 0.0100 0.0005
10 0.0387 nan 0.0100 0.0002
20 0.0348 nan 0.0100 0.0004
40 0.0276 nan 0.0100 0.0003
60 0.0227 nan 0.0100 0.0002
80 0.0186 nan 0.0100 0.0001
100 0.0151 nan 0.0100 0.0002
120 0.0124 nan 0.0100 0.0000
140 0.0103 nan 0.0100 -0.0000
160 0.0087 nan 0.0100 0.0000
180 0.0072 nan 0.0100 0.0000
200 0.0062 nan 0.0100 0.0000
- Fold05: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold05: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0431 nan 0.0100 0.0005
2 0.0426 nan 0.0100 0.0004
3 0.0421 nan 0.0100 0.0005
4 0.0415 nan 0.0100 0.0005
5 0.0409 nan 0.0100 0.0006
6 0.0403 nan 0.0100 0.0005
7 0.0400 nan 0.0100 0.0002
8 0.0394 nan 0.0100 0.0006
9 0.0389 nan 0.0100 0.0003
10 0.0383 nan 0.0100 0.0004
20 0.0340 nan 0.0100 0.0003
40 0.0271 nan 0.0100 0.0003
60 0.0218 nan 0.0100 0.0001
80 0.0175 nan 0.0100 0.0002
100 0.0146 nan 0.0100 -0.0000
120 0.0122 nan 0.0100 0.0000
140 0.0100 nan 0.0100 0.0001
160 0.0085 nan 0.0100 -0.0001
180 0.0074 nan 0.0100 0.0001
200 0.0063 nan 0.0100 0.0000
- Fold05: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold05: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0432 nan 0.0100 0.0003
2 0.0426 nan 0.0100 0.0005
3 0.0421 nan 0.0100 0.0004
4 0.0415 nan 0.0100 0.0005
5 0.0411 nan 0.0100 0.0004
6 0.0405 nan 0.0100 0.0005
7 0.0402 nan 0.0100 0.0000
8 0.0397 nan 0.0100 0.0005
9 0.0391 nan 0.0100 0.0005
10 0.0386 nan 0.0100 0.0004
20 0.0344 nan 0.0100 0.0003
40 0.0277 nan 0.0100 0.0000
60 0.0223 nan 0.0100 0.0002
80 0.0190 nan 0.0100 0.0001
100 0.0158 nan 0.0100 0.0001
120 0.0133 nan 0.0100 0.0001
140 0.0117 nan 0.0100 0.0000
160 0.0100 nan 0.0100 0.0000
180 0.0089 nan 0.0100 0.0000
200 0.0080 nan 0.0100 0.0000
- Fold05: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold05: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0430 nan 0.0100 0.0004
2 0.0423 nan 0.0100 0.0005
3 0.0417 nan 0.0100 0.0005
4 0.0411 nan 0.0100 0.0002
5 0.0403 nan 0.0100 0.0006
6 0.0401 nan 0.0100 -0.0001
7 0.0395 nan 0.0100 0.0005
8 0.0390 nan 0.0100 0.0004
9 0.0384 nan 0.0100 0.0004
10 0.0379 nan 0.0100 0.0005
20 0.0329 nan 0.0100 0.0004
40 0.0244 nan 0.0100 0.0004
60 0.0190 nan 0.0100 0.0003
80 0.0145 nan 0.0100 0.0002
100 0.0113 nan 0.0100 0.0001
120 0.0092 nan 0.0100 0.0001
140 0.0074 nan 0.0100 0.0001
160 0.0060 nan 0.0100 0.0000
180 0.0048 nan 0.0100 0.0001
200 0.0040 nan 0.0100 0.0000
- Fold05: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold05: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0431 nan 0.0100 0.0003
2 0.0424 nan 0.0100 0.0004
3 0.0419 nan 0.0100 0.0004
4 0.0414 nan 0.0100 0.0006
5 0.0408 nan 0.0100 0.0005
6 0.0402 nan 0.0100 0.0005
7 0.0396 nan 0.0100 0.0004
8 0.0391 nan 0.0100 0.0005
9 0.0388 nan 0.0100 0.0001
10 0.0382 nan 0.0100 0.0005
20 0.0336 nan 0.0100 0.0002
40 0.0259 nan 0.0100 0.0004
60 0.0204 nan 0.0100 0.0002
80 0.0159 nan 0.0100 0.0001
100 0.0124 nan 0.0100 0.0002
120 0.0099 nan 0.0100 0.0001
140 0.0081 nan 0.0100 0.0001
160 0.0065 nan 0.0100 0.0000
180 0.0053 nan 0.0100 -0.0000
200 0.0044 nan 0.0100 0.0000
- Fold05: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold05: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0432 nan 0.0100 0.0000
2 0.0427 nan 0.0100 0.0004
3 0.0422 nan 0.0100 0.0005
4 0.0415 nan 0.0100 0.0006
5 0.0412 nan 0.0100 0.0003
6 0.0407 nan 0.0100 0.0005
7 0.0402 nan 0.0100 0.0005
8 0.0395 nan 0.0100 0.0003
9 0.0390 nan 0.0100 0.0005
10 0.0385 nan 0.0100 0.0003
20 0.0350 nan 0.0100 0.0000
40 0.0279 nan 0.0100 0.0003
60 0.0229 nan 0.0100 0.0001
80 0.0193 nan 0.0100 0.0001
100 0.0163 nan 0.0100 0.0002
120 0.0142 nan 0.0100 0.0001
140 0.0122 nan 0.0100 0.0001
160 0.0106 nan 0.0100 -0.0001
180 0.0094 nan 0.0100 0.0000
200 0.0084 nan 0.0100 0.0000
- Fold05: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold05: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0429 nan 0.0100 0.0005
2 0.0424 nan 0.0100 0.0003
3 0.0416 nan 0.0100 0.0006
4 0.0410 nan 0.0100 0.0005
5 0.0403 nan 0.0100 0.0005
6 0.0399 nan 0.0100 0.0002
7 0.0391 nan 0.0100 0.0005
8 0.0384 nan 0.0100 0.0007
9 0.0378 nan 0.0100 0.0003
10 0.0372 nan 0.0100 0.0007
20 0.0321 nan 0.0100 0.0006
40 0.0240 nan 0.0100 0.0001
60 0.0179 nan 0.0100 0.0001
80 0.0131 nan 0.0100 0.0001
100 0.0100 nan 0.0100 0.0001
120 0.0078 nan 0.0100 0.0001
140 0.0061 nan 0.0100 0.0001
160 0.0049 nan 0.0100 0.0000
180 0.0039 nan 0.0100 0.0000
200 0.0030 nan 0.0100 0.0000
- Fold05: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold05: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0429 nan 0.0100 0.0007
2 0.0425 nan 0.0100 0.0004
3 0.0421 nan 0.0100 0.0003
4 0.0416 nan 0.0100 0.0003
5 0.0413 nan 0.0100 0.0000
6 0.0407 nan 0.0100 0.0006
7 0.0399 nan 0.0100 0.0005
8 0.0393 nan 0.0100 0.0004
9 0.0387 nan 0.0100 0.0003
10 0.0383 nan 0.0100 0.0005
20 0.0333 nan 0.0100 0.0004
40 0.0260 nan 0.0100 0.0001
60 0.0205 nan 0.0100 0.0003
80 0.0154 nan 0.0100 0.0001
100 0.0121 nan 0.0100 0.0001
120 0.0096 nan 0.0100 0.0001
140 0.0076 nan 0.0100 0.0000
160 0.0062 nan 0.0100 -0.0001
180 0.0052 nan 0.0100 0.0000
200 0.0042 nan 0.0100 0.0000
- Fold05: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold05: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0429 nan 0.0100 0.0006
2 0.0427 nan 0.0100 -0.0002
3 0.0420 nan 0.0100 0.0006
4 0.0417 nan 0.0100 0.0004
5 0.0411 nan 0.0100 0.0004
6 0.0405 nan 0.0100 0.0006
7 0.0398 nan 0.0100 0.0005
8 0.0395 nan 0.0100 0.0000
9 0.0389 nan 0.0100 0.0002
10 0.0385 nan 0.0100 0.0005
20 0.0340 nan 0.0100 -0.0001
40 0.0275 nan 0.0100 0.0002
60 0.0223 nan 0.0100 -0.0000
80 0.0186 nan 0.0100 0.0001
100 0.0153 nan 0.0100 0.0000
120 0.0134 nan 0.0100 0.0000
140 0.0117 nan 0.0100 0.0000
160 0.0101 nan 0.0100 -0.0000
180 0.0090 nan 0.0100 0.0000
200 0.0082 nan 0.0100 -0.0000
- Fold05: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold05: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0409 nan 0.0500 0.0017
2 0.0378 nan 0.0500 0.0025
3 0.0349 nan 0.0500 0.0026
4 0.0327 nan 0.0500 0.0021
5 0.0316 nan 0.0500 0.0002
6 0.0293 nan 0.0500 0.0016
7 0.0282 nan 0.0500 0.0010
8 0.0265 nan 0.0500 0.0010
9 0.0247 nan 0.0500 0.0013
10 0.0236 nan 0.0500 0.0010
20 0.0142 nan 0.0500 0.0006
40 0.0061 nan 0.0500 0.0000
60 0.0028 nan 0.0500 0.0001
80 0.0015 nan 0.0500 -0.0000
100 0.0009 nan 0.0500 -0.0000
120 0.0005 nan 0.0500 0.0000
140 0.0003 nan 0.0500 0.0000
160 0.0002 nan 0.0500 0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 0.0000
- Fold05: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold05: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0415 nan 0.0500 0.0021
2 0.0396 nan 0.0500 0.0013
3 0.0385 nan 0.0500 -0.0004
4 0.0363 nan 0.0500 0.0026
5 0.0339 nan 0.0500 0.0025
6 0.0316 nan 0.0500 0.0019
7 0.0297 nan 0.0500 0.0017
8 0.0284 nan 0.0500 0.0014
9 0.0263 nan 0.0500 0.0008
10 0.0250 nan 0.0500 0.0008
20 0.0144 nan 0.0500 0.0007
40 0.0064 nan 0.0500 0.0002
60 0.0033 nan 0.0500 -0.0001
80 0.0019 nan 0.0500 -0.0000
100 0.0010 nan 0.0500 -0.0000
120 0.0007 nan 0.0500 -0.0000
140 0.0004 nan 0.0500 -0.0000
160 0.0003 nan 0.0500 0.0000
180 0.0002 nan 0.0500 0.0000
200 0.0001 nan 0.0500 0.0000
- Fold05: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold05: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0437 nan 0.0500 -0.0013
2 0.0405 nan 0.0500 0.0028
3 0.0377 nan 0.0500 0.0020
4 0.0367 nan 0.0500 0.0007
5 0.0346 nan 0.0500 0.0020
6 0.0329 nan 0.0500 0.0007
7 0.0318 nan 0.0500 0.0012
8 0.0300 nan 0.0500 0.0019
9 0.0281 nan 0.0500 0.0017
10 0.0269 nan 0.0500 0.0014
20 0.0188 nan 0.0500 0.0002
40 0.0096 nan 0.0500 0.0002
60 0.0055 nan 0.0500 -0.0002
80 0.0037 nan 0.0500 -0.0000
100 0.0025 nan 0.0500 0.0000
120 0.0019 nan 0.0500 0.0000
140 0.0013 nan 0.0500 -0.0000
160 0.0009 nan 0.0500 0.0000
180 0.0007 nan 0.0500 -0.0000
200 0.0006 nan 0.0500 -0.0000
- Fold05: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold05: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0399 nan 0.0500 0.0026
2 0.0368 nan 0.0500 0.0032
3 0.0340 nan 0.0500 0.0024
4 0.0329 nan 0.0500 -0.0011
5 0.0307 nan 0.0500 0.0016
6 0.0291 nan 0.0500 0.0016
7 0.0280 nan 0.0500 0.0007
8 0.0263 nan 0.0500 0.0017
9 0.0248 nan 0.0500 0.0006
10 0.0236 nan 0.0500 0.0009
20 0.0132 nan 0.0500 -0.0002
40 0.0038 nan 0.0500 0.0001
60 0.0015 nan 0.0500 0.0000
80 0.0006 nan 0.0500 -0.0000
100 0.0003 nan 0.0500 0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0001 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold05: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold05: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0406 nan 0.0500 0.0024
2 0.0368 nan 0.0500 0.0030
3 0.0348 nan 0.0500 0.0014
4 0.0319 nan 0.0500 0.0019
5 0.0306 nan 0.0500 0.0008
6 0.0282 nan 0.0500 0.0019
7 0.0266 nan 0.0500 0.0006
8 0.0260 nan 0.0500 -0.0003
9 0.0247 nan 0.0500 0.0013
10 0.0234 nan 0.0500 0.0009
20 0.0136 nan 0.0500 0.0005
40 0.0045 nan 0.0500 -0.0000
60 0.0020 nan 0.0500 -0.0000
80 0.0010 nan 0.0500 -0.0000
100 0.0006 nan 0.0500 -0.0000
120 0.0003 nan 0.0500 -0.0000
140 0.0002 nan 0.0500 0.0000
160 0.0001 nan 0.0500 0.0000
180 0.0001 nan 0.0500 0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold05: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold05: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0408 nan 0.0500 0.0029
2 0.0392 nan 0.0500 0.0009
3 0.0378 nan 0.0500 0.0010
4 0.0353 nan 0.0500 0.0016
5 0.0335 nan 0.0500 0.0020
6 0.0326 nan 0.0500 0.0004
7 0.0313 nan 0.0500 -0.0003
8 0.0300 nan 0.0500 0.0008
9 0.0287 nan 0.0500 0.0012
10 0.0269 nan 0.0500 0.0017
20 0.0167 nan 0.0500 0.0003
40 0.0086 nan 0.0500 -0.0003
60 0.0048 nan 0.0500 0.0000
80 0.0033 nan 0.0500 -0.0001
100 0.0022 nan 0.0500 0.0000
120 0.0016 nan 0.0500 -0.0000
140 0.0011 nan 0.0500 0.0000
160 0.0008 nan 0.0500 0.0000
180 0.0007 nan 0.0500 -0.0000
200 0.0005 nan 0.0500 0.0000
- Fold05: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold05: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0399 nan 0.0500 0.0028
2 0.0366 nan 0.0500 0.0020
3 0.0334 nan 0.0500 0.0017
4 0.0303 nan 0.0500 0.0017
5 0.0276 nan 0.0500 0.0016
6 0.0249 nan 0.0500 0.0023
7 0.0223 nan 0.0500 0.0017
8 0.0208 nan 0.0500 0.0005
9 0.0189 nan 0.0500 0.0012
10 0.0178 nan 0.0500 0.0004
20 0.0088 nan 0.0500 0.0005
40 0.0025 nan 0.0500 0.0001
60 0.0009 nan 0.0500 0.0000
80 0.0003 nan 0.0500 0.0000
100 0.0002 nan 0.0500 -0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0000 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold05: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold05: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0403 nan 0.0500 0.0024
2 0.0379 nan 0.0500 0.0017
3 0.0365 nan 0.0500 -0.0012
4 0.0339 nan 0.0500 0.0024
5 0.0316 nan 0.0500 0.0020
6 0.0295 nan 0.0500 0.0020
7 0.0277 nan 0.0500 0.0001
8 0.0257 nan 0.0500 0.0018
9 0.0244 nan 0.0500 0.0008
10 0.0222 nan 0.0500 0.0015
20 0.0117 nan 0.0500 0.0006
40 0.0048 nan 0.0500 0.0001
60 0.0017 nan 0.0500 -0.0000
80 0.0010 nan 0.0500 0.0000
100 0.0006 nan 0.0500 -0.0000
120 0.0003 nan 0.0500 0.0000
140 0.0003 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold05: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold05: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0409 nan 0.0500 0.0027
2 0.0382 nan 0.0500 0.0024
3 0.0374 nan 0.0500 0.0001
4 0.0355 nan 0.0500 0.0016
5 0.0334 nan 0.0500 0.0013
6 0.0314 nan 0.0500 0.0022
7 0.0303 nan 0.0500 0.0014
8 0.0290 nan 0.0500 0.0014
9 0.0271 nan 0.0500 0.0018
10 0.0254 nan 0.0500 0.0016
20 0.0162 nan 0.0500 0.0004
40 0.0078 nan 0.0500 0.0002
60 0.0053 nan 0.0500 -0.0002
80 0.0035 nan 0.0500 0.0000
100 0.0024 nan 0.0500 0.0000
120 0.0017 nan 0.0500 0.0000
140 0.0011 nan 0.0500 0.0000
160 0.0007 nan 0.0500 -0.0000
180 0.0005 nan 0.0500 -0.0000
200 0.0004 nan 0.0500 -0.0000
- Fold05: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold05: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0375 nan 0.1000 0.0061
2 0.0336 nan 0.1000 0.0013
3 0.0309 nan 0.1000 0.0023
4 0.0274 nan 0.1000 0.0023
5 0.0252 nan 0.1000 0.0015
6 0.0237 nan 0.1000 0.0007
7 0.0233 nan 0.1000 -0.0021
8 0.0212 nan 0.1000 0.0025
9 0.0185 nan 0.1000 0.0005
10 0.0172 nan 0.1000 -0.0003
20 0.0075 nan 0.1000 -0.0001
40 0.0016 nan 0.1000 0.0000
60 0.0006 nan 0.1000 0.0000
80 0.0002 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 0.0000
120 0.0000 nan 0.1000 0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold05: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold05: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0387 nan 0.1000 0.0031
2 0.0333 nan 0.1000 0.0052
3 0.0310 nan 0.1000 0.0015
4 0.0274 nan 0.1000 0.0038
5 0.0243 nan 0.1000 0.0026
6 0.0211 nan 0.1000 0.0025
7 0.0181 nan 0.1000 0.0016
8 0.0161 nan 0.1000 0.0019
9 0.0141 nan 0.1000 0.0016
10 0.0128 nan 0.1000 0.0013
20 0.0063 nan 0.1000 0.0002
40 0.0021 nan 0.1000 -0.0001
60 0.0010 nan 0.1000 -0.0001
80 0.0005 nan 0.1000 0.0000
100 0.0003 nan 0.1000 0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold05: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold05: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0385 nan 0.1000 0.0043
2 0.0349 nan 0.1000 0.0009
3 0.0314 nan 0.1000 0.0028
4 0.0270 nan 0.1000 0.0029
5 0.0244 nan 0.1000 0.0018
6 0.0229 nan 0.1000 0.0010
7 0.0208 nan 0.1000 0.0017
8 0.0201 nan 0.1000 -0.0016
9 0.0190 nan 0.1000 0.0004
10 0.0175 nan 0.1000 0.0009
20 0.0098 nan 0.1000 0.0001
40 0.0038 nan 0.1000 -0.0002
60 0.0017 nan 0.1000 -0.0001
80 0.0009 nan 0.1000 0.0000
100 0.0005 nan 0.1000 0.0000
120 0.0002 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold05: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold05: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0377 nan 0.1000 0.0063
2 0.0344 nan 0.1000 0.0024
3 0.0304 nan 0.1000 0.0044
4 0.0264 nan 0.1000 0.0028
5 0.0244 nan 0.1000 0.0014
6 0.0219 nan 0.1000 0.0028
7 0.0190 nan 0.1000 0.0027
8 0.0160 nan 0.1000 0.0015
9 0.0137 nan 0.1000 0.0010
10 0.0124 nan 0.1000 0.0010
20 0.0033 nan 0.1000 0.0003
40 0.0007 nan 0.1000 0.0001
60 0.0002 nan 0.1000 0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold05: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold05: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0386 nan 0.1000 0.0042
2 0.0333 nan 0.1000 0.0041
3 0.0306 nan 0.1000 0.0028
4 0.0282 nan 0.1000 0.0020
5 0.0244 nan 0.1000 0.0022
6 0.0214 nan 0.1000 0.0020
7 0.0192 nan 0.1000 0.0016
8 0.0172 nan 0.1000 0.0016
9 0.0150 nan 0.1000 0.0007
10 0.0138 nan 0.1000 0.0008
20 0.0055 nan 0.1000 -0.0001
40 0.0010 nan 0.1000 0.0000
60 0.0003 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold05: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold05: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0379 nan 0.1000 0.0057
2 0.0352 nan 0.1000 0.0017
3 0.0310 nan 0.1000 0.0023
4 0.0280 nan 0.1000 0.0018
5 0.0259 nan 0.1000 0.0019
6 0.0232 nan 0.1000 0.0029
7 0.0212 nan 0.1000 0.0023
8 0.0189 nan 0.1000 0.0013
9 0.0181 nan 0.1000 0.0002
10 0.0169 nan 0.1000 0.0003
20 0.0111 nan 0.1000 -0.0004
40 0.0045 nan 0.1000 -0.0001
60 0.0023 nan 0.1000 0.0001
80 0.0014 nan 0.1000 0.0000
100 0.0007 nan 0.1000 -0.0000
120 0.0004 nan 0.1000 0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0002 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold05: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold05: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0358 nan 0.1000 0.0055
2 0.0321 nan 0.1000 0.0032
3 0.0280 nan 0.1000 0.0025
4 0.0255 nan 0.1000 -0.0003
5 0.0230 nan 0.1000 0.0019
6 0.0194 nan 0.1000 0.0025
7 0.0171 nan 0.1000 0.0026
8 0.0142 nan 0.1000 0.0021
9 0.0125 nan 0.1000 0.0005
10 0.0108 nan 0.1000 0.0003
20 0.0031 nan 0.1000 0.0002
40 0.0005 nan 0.1000 0.0000
60 0.0001 nan 0.1000 -0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold05: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold05: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0359 nan 0.1000 0.0052
2 0.0303 nan 0.1000 0.0040
3 0.0272 nan 0.1000 0.0033
4 0.0254 nan 0.1000 0.0002
5 0.0202 nan 0.1000 0.0035
6 0.0180 nan 0.1000 0.0019
7 0.0170 nan 0.1000 0.0004
8 0.0156 nan 0.1000 0.0008
9 0.0139 nan 0.1000 0.0010
10 0.0121 nan 0.1000 0.0014
20 0.0039 nan 0.1000 0.0002
40 0.0009 nan 0.1000 -0.0000
60 0.0004 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold05: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold05: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0376 nan 0.1000 0.0048
2 0.0324 nan 0.1000 0.0024
3 0.0278 nan 0.1000 0.0026
4 0.0244 nan 0.1000 0.0021
5 0.0222 nan 0.1000 0.0018
6 0.0203 nan 0.1000 0.0016
7 0.0180 nan 0.1000 0.0015
8 0.0166 nan 0.1000 0.0009
9 0.0153 nan 0.1000 0.0004
10 0.0143 nan 0.1000 0.0004
20 0.0076 nan 0.1000 0.0002
40 0.0034 nan 0.1000 -0.0001
60 0.0013 nan 0.1000 0.0001
80 0.0006 nan 0.1000 -0.0000
100 0.0003 nan 0.1000 -0.0000
120 0.0002 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold05: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold06: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0424 nan 0.0100 0.0006
2 0.0419 nan 0.0100 0.0002
3 0.0413 nan 0.0100 0.0006
4 0.0409 nan 0.0100 0.0005
5 0.0407 nan 0.0100 0.0001
6 0.0400 nan 0.0100 0.0003
7 0.0396 nan 0.0100 0.0005
8 0.0392 nan 0.0100 0.0002
9 0.0389 nan 0.0100 0.0002
10 0.0382 nan 0.0100 0.0005
20 0.0339 nan 0.0100 0.0003
40 0.0276 nan 0.0100 0.0000
60 0.0220 nan 0.0100 0.0002
80 0.0180 nan 0.0100 0.0002
100 0.0148 nan 0.0100 0.0001
120 0.0124 nan 0.0100 -0.0000
140 0.0104 nan 0.0100 0.0000
160 0.0086 nan 0.0100 0.0001
180 0.0072 nan 0.0100 0.0000
200 0.0061 nan 0.0100 0.0001
- Fold06: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold06: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0424 nan 0.0100 0.0004
2 0.0418 nan 0.0100 0.0006
3 0.0413 nan 0.0100 0.0005
4 0.0408 nan 0.0100 0.0005
5 0.0405 nan 0.0100 0.0002
6 0.0401 nan 0.0100 0.0002
7 0.0396 nan 0.0100 0.0005
8 0.0391 nan 0.0100 0.0005
9 0.0387 nan 0.0100 0.0001
10 0.0381 nan 0.0100 0.0005
20 0.0342 nan 0.0100 0.0003
40 0.0271 nan 0.0100 0.0001
60 0.0220 nan 0.0100 0.0002
80 0.0186 nan 0.0100 0.0001
100 0.0153 nan 0.0100 0.0001
120 0.0127 nan 0.0100 0.0001
140 0.0107 nan 0.0100 0.0001
160 0.0090 nan 0.0100 0.0001
180 0.0077 nan 0.0100 0.0001
200 0.0065 nan 0.0100 0.0000
- Fold06: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold06: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0425 nan 0.0100 0.0004
2 0.0418 nan 0.0100 0.0005
3 0.0414 nan 0.0100 0.0003
4 0.0409 nan 0.0100 0.0003
5 0.0403 nan 0.0100 0.0006
6 0.0398 nan 0.0100 0.0005
7 0.0392 nan 0.0100 0.0004
8 0.0388 nan 0.0100 0.0004
9 0.0384 nan 0.0100 0.0005
10 0.0378 nan 0.0100 0.0005
20 0.0340 nan 0.0100 0.0004
40 0.0268 nan 0.0100 0.0003
60 0.0217 nan 0.0100 0.0001
80 0.0184 nan 0.0100 0.0001
100 0.0155 nan 0.0100 0.0001
120 0.0133 nan 0.0100 -0.0000
140 0.0113 nan 0.0100 0.0001
160 0.0100 nan 0.0100 -0.0000
180 0.0088 nan 0.0100 0.0000
200 0.0079 nan 0.0100 0.0000
- Fold06: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold06: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0423 nan 0.0100 0.0005
2 0.0417 nan 0.0100 0.0004
3 0.0411 nan 0.0100 0.0005
4 0.0403 nan 0.0100 0.0004
5 0.0399 nan 0.0100 0.0002
6 0.0394 nan 0.0100 0.0005
7 0.0389 nan 0.0100 0.0005
8 0.0381 nan 0.0100 0.0004
9 0.0375 nan 0.0100 0.0006
10 0.0369 nan 0.0100 0.0005
20 0.0322 nan 0.0100 0.0005
40 0.0246 nan 0.0100 0.0003
60 0.0188 nan 0.0100 0.0002
80 0.0150 nan 0.0100 0.0001
100 0.0119 nan 0.0100 0.0001
120 0.0091 nan 0.0100 0.0001
140 0.0071 nan 0.0100 0.0001
160 0.0057 nan 0.0100 0.0000
180 0.0046 nan 0.0100 0.0000
200 0.0037 nan 0.0100 0.0000
- Fold06: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold06: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0424 nan 0.0100 0.0004
2 0.0421 nan 0.0100 0.0002
3 0.0414 nan 0.0100 0.0006
4 0.0407 nan 0.0100 0.0006
5 0.0402 nan 0.0100 0.0003
6 0.0395 nan 0.0100 0.0007
7 0.0389 nan 0.0100 0.0002
8 0.0384 nan 0.0100 0.0005
9 0.0378 nan 0.0100 0.0004
10 0.0372 nan 0.0100 0.0004
20 0.0323 nan 0.0100 0.0005
40 0.0246 nan 0.0100 0.0001
60 0.0189 nan 0.0100 0.0002
80 0.0145 nan 0.0100 0.0001
100 0.0113 nan 0.0100 0.0001
120 0.0091 nan 0.0100 0.0001
140 0.0073 nan 0.0100 0.0000
160 0.0061 nan 0.0100 0.0000
180 0.0051 nan 0.0100 0.0000
200 0.0041 nan 0.0100 0.0000
- Fold06: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold06: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0424 nan 0.0100 0.0006
2 0.0420 nan 0.0100 0.0003
3 0.0416 nan 0.0100 0.0003
4 0.0411 nan 0.0100 0.0005
5 0.0407 nan 0.0100 0.0004
6 0.0400 nan 0.0100 0.0004
7 0.0396 nan 0.0100 0.0005
8 0.0393 nan 0.0100 0.0001
9 0.0389 nan 0.0100 0.0002
10 0.0384 nan 0.0100 0.0004
20 0.0340 nan 0.0100 0.0004
40 0.0281 nan 0.0100 0.0002
60 0.0227 nan 0.0100 0.0000
80 0.0191 nan 0.0100 0.0001
100 0.0162 nan 0.0100 0.0001
120 0.0139 nan 0.0100 -0.0000
140 0.0119 nan 0.0100 0.0001
160 0.0104 nan 0.0100 0.0000
180 0.0089 nan 0.0100 0.0000
200 0.0081 nan 0.0100 -0.0001
- Fold06: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold06: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0425 nan 0.0100 0.0005
2 0.0420 nan 0.0100 0.0002
3 0.0413 nan 0.0100 0.0002
4 0.0406 nan 0.0100 0.0007
5 0.0400 nan 0.0100 0.0003
6 0.0396 nan 0.0100 0.0004
7 0.0389 nan 0.0100 0.0006
8 0.0383 nan 0.0100 0.0003
9 0.0377 nan 0.0100 0.0005
10 0.0371 nan 0.0100 0.0005
20 0.0318 nan 0.0100 0.0005
40 0.0242 nan 0.0100 0.0001
60 0.0180 nan 0.0100 0.0002
80 0.0139 nan 0.0100 0.0001
100 0.0108 nan 0.0100 0.0002
120 0.0084 nan 0.0100 0.0000
140 0.0066 nan 0.0100 0.0000
160 0.0053 nan 0.0100 0.0000
180 0.0041 nan 0.0100 0.0000
200 0.0033 nan 0.0100 0.0000
- Fold06: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold06: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0425 nan 0.0100 0.0003
2 0.0418 nan 0.0100 0.0005
3 0.0413 nan 0.0100 0.0001
4 0.0405 nan 0.0100 0.0006
5 0.0399 nan 0.0100 0.0006
6 0.0394 nan 0.0100 0.0003
7 0.0389 nan 0.0100 0.0005
8 0.0385 nan 0.0100 0.0003
9 0.0382 nan 0.0100 0.0002
10 0.0379 nan 0.0100 0.0003
20 0.0334 nan 0.0100 0.0002
40 0.0259 nan 0.0100 0.0003
60 0.0201 nan 0.0100 0.0002
80 0.0160 nan 0.0100 0.0001
100 0.0124 nan 0.0100 0.0001
120 0.0100 nan 0.0100 0.0001
140 0.0083 nan 0.0100 0.0000
160 0.0068 nan 0.0100 0.0000
180 0.0056 nan 0.0100 0.0000
200 0.0046 nan 0.0100 0.0000
- Fold06: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold06: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0424 nan 0.0100 0.0005
2 0.0417 nan 0.0100 0.0006
3 0.0413 nan 0.0100 0.0005
4 0.0408 nan 0.0100 0.0004
5 0.0404 nan 0.0100 0.0005
6 0.0402 nan 0.0100 -0.0001
7 0.0396 nan 0.0100 0.0005
8 0.0389 nan 0.0100 0.0003
9 0.0386 nan 0.0100 -0.0000
10 0.0381 nan 0.0100 0.0005
20 0.0338 nan 0.0100 0.0003
40 0.0272 nan 0.0100 0.0001
60 0.0226 nan 0.0100 0.0001
80 0.0188 nan 0.0100 0.0001
100 0.0159 nan 0.0100 0.0001
120 0.0136 nan 0.0100 0.0001
140 0.0119 nan 0.0100 0.0000
160 0.0106 nan 0.0100 0.0000
180 0.0093 nan 0.0100 0.0000
200 0.0084 nan 0.0100 -0.0000
- Fold06: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold06: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0403 nan 0.0500 0.0027
2 0.0372 nan 0.0500 0.0025
3 0.0346 nan 0.0500 0.0019
4 0.0326 nan 0.0500 0.0018
5 0.0303 nan 0.0500 0.0023
6 0.0282 nan 0.0500 0.0012
7 0.0271 nan 0.0500 0.0013
8 0.0257 nan 0.0500 0.0012
9 0.0245 nan 0.0500 0.0006
10 0.0231 nan 0.0500 0.0013
20 0.0140 nan 0.0500 0.0005
40 0.0063 nan 0.0500 0.0000
60 0.0031 nan 0.0500 0.0000
80 0.0017 nan 0.0500 0.0000
100 0.0011 nan 0.0500 -0.0000
120 0.0006 nan 0.0500 0.0000
140 0.0004 nan 0.0500 0.0000
160 0.0002 nan 0.0500 0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold06: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold06: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0406 nan 0.0500 0.0016
2 0.0382 nan 0.0500 0.0014
3 0.0366 nan 0.0500 0.0002
4 0.0342 nan 0.0500 0.0026
5 0.0328 nan 0.0500 -0.0001
6 0.0316 nan 0.0500 0.0011
7 0.0293 nan 0.0500 0.0016
8 0.0276 nan 0.0500 0.0017
9 0.0263 nan 0.0500 0.0012
10 0.0257 nan 0.0500 -0.0003
20 0.0149 nan 0.0500 0.0006
40 0.0066 nan 0.0500 0.0003
60 0.0038 nan 0.0500 -0.0001
80 0.0020 nan 0.0500 -0.0000
100 0.0011 nan 0.0500 -0.0000
120 0.0006 nan 0.0500 0.0000
140 0.0004 nan 0.0500 0.0000
160 0.0003 nan 0.0500 0.0000
180 0.0002 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 0.0000
- Fold06: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold06: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0404 nan 0.0500 0.0027
2 0.0382 nan 0.0500 0.0013
3 0.0366 nan 0.0500 0.0008
4 0.0346 nan 0.0500 0.0021
5 0.0324 nan 0.0500 0.0020
6 0.0302 nan 0.0500 0.0020
7 0.0280 nan 0.0500 0.0017
8 0.0262 nan 0.0500 0.0013
9 0.0249 nan 0.0500 0.0011
10 0.0234 nan 0.0500 0.0014
20 0.0161 nan 0.0500 0.0002
40 0.0079 nan 0.0500 0.0003
60 0.0045 nan 0.0500 0.0000
80 0.0027 nan 0.0500 -0.0000
100 0.0019 nan 0.0500 -0.0000
120 0.0013 nan 0.0500 -0.0000
140 0.0010 nan 0.0500 -0.0000
160 0.0007 nan 0.0500 -0.0000
180 0.0006 nan 0.0500 -0.0000
200 0.0005 nan 0.0500 -0.0000
- Fold06: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold06: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0414 nan 0.0500 -0.0007
2 0.0380 nan 0.0500 0.0029
3 0.0357 nan 0.0500 -0.0002
4 0.0331 nan 0.0500 0.0015
5 0.0304 nan 0.0500 0.0027
6 0.0292 nan 0.0500 0.0007
7 0.0270 nan 0.0500 0.0008
8 0.0263 nan 0.0500 -0.0002
9 0.0245 nan 0.0500 0.0016
10 0.0227 nan 0.0500 0.0009
20 0.0125 nan 0.0500 0.0009
40 0.0040 nan 0.0500 -0.0000
60 0.0016 nan 0.0500 0.0000
80 0.0007 nan 0.0500 -0.0000
100 0.0003 nan 0.0500 -0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0001 nan 0.0500 0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold06: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold06: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0410 nan 0.0500 0.0018
2 0.0380 nan 0.0500 0.0021
3 0.0352 nan 0.0500 0.0011
4 0.0323 nan 0.0500 0.0028
5 0.0301 nan 0.0500 0.0021
6 0.0285 nan 0.0500 0.0019
7 0.0275 nan 0.0500 0.0001
8 0.0258 nan 0.0500 0.0015
9 0.0245 nan 0.0500 0.0014
10 0.0241 nan 0.0500 -0.0007
20 0.0127 nan 0.0500 -0.0001
40 0.0047 nan 0.0500 0.0001
60 0.0020 nan 0.0500 0.0001
80 0.0011 nan 0.0500 -0.0000
100 0.0006 nan 0.0500 -0.0000
120 0.0003 nan 0.0500 0.0000
140 0.0002 nan 0.0500 0.0000
160 0.0001 nan 0.0500 0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold06: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold06: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0416 nan 0.0500 0.0004
2 0.0386 nan 0.0500 0.0027
3 0.0369 nan 0.0500 -0.0005
4 0.0349 nan 0.0500 0.0023
5 0.0338 nan 0.0500 0.0007
6 0.0321 nan 0.0500 0.0008
7 0.0306 nan 0.0500 0.0003
8 0.0282 nan 0.0500 0.0018
9 0.0271 nan 0.0500 0.0012
10 0.0260 nan 0.0500 0.0005
20 0.0162 nan 0.0500 0.0003
40 0.0091 nan 0.0500 0.0000
60 0.0053 nan 0.0500 0.0000
80 0.0035 nan 0.0500 -0.0000
100 0.0024 nan 0.0500 -0.0001
120 0.0019 nan 0.0500 -0.0000
140 0.0014 nan 0.0500 -0.0001
160 0.0009 nan 0.0500 0.0000
180 0.0007 nan 0.0500 0.0000
200 0.0005 nan 0.0500 -0.0000
- Fold06: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold06: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0396 nan 0.0500 0.0034
2 0.0369 nan 0.0500 0.0023
3 0.0346 nan 0.0500 0.0007
4 0.0330 nan 0.0500 0.0011
5 0.0318 nan 0.0500 0.0011
6 0.0287 nan 0.0500 0.0023
7 0.0280 nan 0.0500 -0.0011
8 0.0270 nan 0.0500 -0.0006
9 0.0253 nan 0.0500 0.0015
10 0.0238 nan 0.0500 0.0008
20 0.0116 nan 0.0500 0.0008
40 0.0038 nan 0.0500 0.0002
60 0.0015 nan 0.0500 -0.0000
80 0.0006 nan 0.0500 -0.0000
100 0.0003 nan 0.0500 0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0001 nan 0.0500 0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold06: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold06: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0395 nan 0.0500 0.0030
2 0.0362 nan 0.0500 0.0028
3 0.0338 nan 0.0500 0.0005
4 0.0306 nan 0.0500 0.0019
5 0.0284 nan 0.0500 0.0015
6 0.0256 nan 0.0500 0.0019
7 0.0232 nan 0.0500 0.0012
8 0.0223 nan 0.0500 -0.0004
9 0.0210 nan 0.0500 0.0015
10 0.0201 nan 0.0500 0.0007
20 0.0117 nan 0.0500 0.0005
40 0.0041 nan 0.0500 0.0002
60 0.0019 nan 0.0500 0.0001
80 0.0010 nan 0.0500 -0.0000
100 0.0006 nan 0.0500 -0.0000
120 0.0003 nan 0.0500 -0.0000
140 0.0002 nan 0.0500 -0.0000
160 0.0001 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 0.0000
- Fold06: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold06: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0409 nan 0.0500 0.0013
2 0.0402 nan 0.0500 0.0002
3 0.0376 nan 0.0500 0.0025
4 0.0361 nan 0.0500 0.0016
5 0.0331 nan 0.0500 0.0017
6 0.0313 nan 0.0500 0.0012
7 0.0306 nan 0.0500 0.0001
8 0.0290 nan 0.0500 0.0009
9 0.0282 nan 0.0500 -0.0001
10 0.0268 nan 0.0500 0.0015
20 0.0171 nan 0.0500 0.0006
40 0.0087 nan 0.0500 0.0001
60 0.0050 nan 0.0500 -0.0001
80 0.0035 nan 0.0500 0.0000
100 0.0024 nan 0.0500 -0.0000
120 0.0019 nan 0.0500 -0.0000
140 0.0013 nan 0.0500 -0.0000
160 0.0010 nan 0.0500 -0.0000
180 0.0007 nan 0.0500 -0.0000
200 0.0005 nan 0.0500 0.0000
- Fold06: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold06: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0383 nan 0.1000 0.0035
2 0.0336 nan 0.1000 0.0045
3 0.0299 nan 0.1000 0.0010
4 0.0286 nan 0.1000 0.0001
5 0.0279 nan 0.1000 -0.0013
6 0.0246 nan 0.1000 0.0034
7 0.0219 nan 0.1000 0.0024
8 0.0191 nan 0.1000 0.0004
9 0.0169 nan 0.1000 0.0001
10 0.0151 nan 0.1000 0.0020
20 0.0050 nan 0.1000 0.0001
40 0.0014 nan 0.1000 0.0000
60 0.0006 nan 0.1000 -0.0000
80 0.0003 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold06: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold06: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0380 nan 0.1000 0.0053
2 0.0343 nan 0.1000 0.0019
3 0.0301 nan 0.1000 0.0039
4 0.0289 nan 0.1000 -0.0005
5 0.0250 nan 0.1000 0.0029
6 0.0222 nan 0.1000 0.0015
7 0.0204 nan 0.1000 0.0006
8 0.0181 nan 0.1000 0.0017
9 0.0173 nan 0.1000 0.0001
10 0.0160 nan 0.1000 0.0001
20 0.0080 nan 0.1000 0.0005
40 0.0023 nan 0.1000 -0.0000
60 0.0007 nan 0.1000 -0.0000
80 0.0003 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 0.0000
120 0.0001 nan 0.1000 0.0000
140 0.0000 nan 0.1000 0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold06: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold06: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0391 nan 0.1000 0.0030
2 0.0342 nan 0.1000 0.0049
3 0.0312 nan 0.1000 0.0024
4 0.0267 nan 0.1000 0.0031
5 0.0233 nan 0.1000 0.0026
6 0.0224 nan 0.1000 0.0007
7 0.0202 nan 0.1000 0.0022
8 0.0171 nan 0.1000 0.0007
9 0.0161 nan 0.1000 0.0000
10 0.0143 nan 0.1000 0.0006
20 0.0071 nan 0.1000 0.0006
40 0.0028 nan 0.1000 -0.0001
60 0.0010 nan 0.1000 -0.0001
80 0.0005 nan 0.1000 -0.0000
100 0.0003 nan 0.1000 -0.0000
120 0.0002 nan 0.1000 0.0000
140 0.0001 nan 0.1000 0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold06: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold06: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0387 nan 0.1000 0.0042
2 0.0325 nan 0.1000 0.0052
3 0.0269 nan 0.1000 0.0029
4 0.0242 nan 0.1000 0.0012
5 0.0213 nan 0.1000 0.0014
6 0.0189 nan 0.1000 0.0011
7 0.0171 nan 0.1000 0.0020
8 0.0147 nan 0.1000 0.0011
9 0.0130 nan 0.1000 0.0010
10 0.0115 nan 0.1000 0.0013
20 0.0039 nan 0.1000 -0.0001
40 0.0007 nan 0.1000 -0.0000
60 0.0002 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold06: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold06: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0356 nan 0.1000 0.0059
2 0.0307 nan 0.1000 0.0048
3 0.0283 nan 0.1000 0.0009
4 0.0252 nan 0.1000 0.0023
5 0.0222 nan 0.1000 0.0020
6 0.0192 nan 0.1000 0.0018
7 0.0161 nan 0.1000 0.0018
8 0.0139 nan 0.1000 0.0013
9 0.0134 nan 0.1000 0.0001
10 0.0120 nan 0.1000 0.0014
20 0.0041 nan 0.1000 0.0001
40 0.0013 nan 0.1000 0.0000
60 0.0004 nan 0.1000 -0.0000
80 0.0002 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 0.0000
200 0.0000 nan 0.1000 0.0000
- Fold06: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold06: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0407 nan 0.1000 -0.0000
2 0.0355 nan 0.1000 0.0052
3 0.0328 nan 0.1000 0.0008
4 0.0289 nan 0.1000 0.0040
5 0.0257 nan 0.1000 0.0032
6 0.0247 nan 0.1000 -0.0010
7 0.0222 nan 0.1000 0.0021
8 0.0204 nan 0.1000 0.0012
9 0.0187 nan 0.1000 0.0015
10 0.0168 nan 0.1000 0.0015
20 0.0076 nan 0.1000 0.0004
40 0.0029 nan 0.1000 -0.0001
60 0.0015 nan 0.1000 0.0000
80 0.0007 nan 0.1000 -0.0000
100 0.0004 nan 0.1000 -0.0000
120 0.0002 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold06: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold06: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0385 nan 0.1000 0.0015
2 0.0315 nan 0.1000 0.0051
3 0.0267 nan 0.1000 0.0039
4 0.0218 nan 0.1000 0.0039
5 0.0186 nan 0.1000 0.0012
6 0.0168 nan 0.1000 0.0015
7 0.0151 nan 0.1000 0.0007
8 0.0135 nan 0.1000 0.0009
9 0.0116 nan 0.1000 0.0012
10 0.0100 nan 0.1000 0.0015
20 0.0034 nan 0.1000 0.0002
40 0.0006 nan 0.1000 -0.0000
60 0.0002 nan 0.1000 -0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold06: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold06: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0369 nan 0.1000 0.0059
2 0.0309 nan 0.1000 0.0056
3 0.0281 nan 0.1000 0.0026
4 0.0255 nan 0.1000 0.0012
5 0.0228 nan 0.1000 0.0009
6 0.0211 nan 0.1000 0.0009
7 0.0194 nan 0.1000 -0.0004
8 0.0181 nan 0.1000 0.0008
9 0.0154 nan 0.1000 0.0014
10 0.0136 nan 0.1000 0.0013
20 0.0051 nan 0.1000 0.0001
40 0.0018 nan 0.1000 -0.0001
60 0.0006 nan 0.1000 -0.0000
80 0.0004 nan 0.1000 -0.0000
100 0.0002 nan 0.1000 -0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold06: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold06: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0379 nan 0.1000 0.0040
2 0.0338 nan 0.1000 0.0032
3 0.0295 nan 0.1000 0.0039
4 0.0266 nan 0.1000 0.0022
5 0.0234 nan 0.1000 0.0025
6 0.0204 nan 0.1000 0.0025
7 0.0192 nan 0.1000 0.0006
8 0.0169 nan 0.1000 0.0010
9 0.0152 nan 0.1000 0.0012
10 0.0142 nan 0.1000 0.0001
20 0.0076 nan 0.1000 -0.0004
40 0.0029 nan 0.1000 0.0001
60 0.0016 nan 0.1000 0.0000
80 0.0009 nan 0.1000 -0.0000
100 0.0005 nan 0.1000 -0.0000
120 0.0003 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0002 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 0.0000
- Fold06: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold07: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0424 nan 0.0100 0.0004
2 0.0418 nan 0.0100 0.0006
3 0.0412 nan 0.0100 0.0006
4 0.0408 nan 0.0100 0.0001
5 0.0403 nan 0.0100 0.0005
6 0.0398 nan 0.0100 0.0005
7 0.0393 nan 0.0100 0.0004
8 0.0388 nan 0.0100 0.0003
9 0.0383 nan 0.0100 0.0003
10 0.0378 nan 0.0100 0.0005
20 0.0336 nan 0.0100 0.0002
40 0.0269 nan 0.0100 0.0003
60 0.0219 nan 0.0100 0.0002
80 0.0178 nan 0.0100 0.0002
100 0.0146 nan 0.0100 0.0001
120 0.0120 nan 0.0100 0.0001
140 0.0103 nan 0.0100 0.0000
160 0.0085 nan 0.0100 0.0000
180 0.0072 nan 0.0100 0.0000
200 0.0061 nan 0.0100 0.0000
- Fold07: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold07: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0424 nan 0.0100 0.0004
2 0.0419 nan 0.0100 0.0006
3 0.0413 nan 0.0100 0.0006
4 0.0407 nan 0.0100 0.0005
5 0.0403 nan 0.0100 0.0004
6 0.0400 nan 0.0100 0.0005
7 0.0395 nan 0.0100 0.0003
8 0.0392 nan 0.0100 -0.0000
9 0.0389 nan 0.0100 0.0003
10 0.0387 nan 0.0100 -0.0000
20 0.0346 nan 0.0100 0.0003
40 0.0277 nan 0.0100 -0.0000
60 0.0226 nan 0.0100 0.0001
80 0.0189 nan 0.0100 0.0002
100 0.0157 nan 0.0100 0.0001
120 0.0129 nan 0.0100 0.0002
140 0.0107 nan 0.0100 0.0001
160 0.0090 nan 0.0100 0.0000
180 0.0077 nan 0.0100 0.0000
200 0.0065 nan 0.0100 0.0001
- Fold07: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold07: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0424 nan 0.0100 0.0005
2 0.0419 nan 0.0100 0.0004
3 0.0415 nan 0.0100 0.0005
4 0.0410 nan 0.0100 0.0004
5 0.0404 nan 0.0100 0.0003
6 0.0399 nan 0.0100 0.0005
7 0.0394 nan 0.0100 0.0005
8 0.0388 nan 0.0100 0.0002
9 0.0383 nan 0.0100 0.0003
10 0.0380 nan 0.0100 0.0000
20 0.0334 nan 0.0100 0.0003
40 0.0268 nan 0.0100 0.0002
60 0.0219 nan 0.0100 0.0002
80 0.0181 nan 0.0100 0.0001
100 0.0155 nan 0.0100 0.0001
120 0.0131 nan 0.0100 0.0001
140 0.0111 nan 0.0100 0.0001
160 0.0099 nan 0.0100 0.0000
180 0.0089 nan 0.0100 0.0000
200 0.0079 nan 0.0100 -0.0000
- Fold07: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold07: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0422 nan 0.0100 0.0006
2 0.0414 nan 0.0100 0.0009
3 0.0408 nan 0.0100 0.0005
4 0.0401 nan 0.0100 0.0006
5 0.0396 nan 0.0100 0.0003
6 0.0390 nan 0.0100 0.0003
7 0.0385 nan 0.0100 0.0005
8 0.0381 nan 0.0100 0.0001
9 0.0374 nan 0.0100 0.0006
10 0.0367 nan 0.0100 0.0006
20 0.0318 nan 0.0100 0.0003
40 0.0245 nan 0.0100 0.0001
60 0.0192 nan 0.0100 0.0001
80 0.0145 nan 0.0100 0.0001
100 0.0116 nan 0.0100 0.0002
120 0.0093 nan 0.0100 0.0001
140 0.0075 nan 0.0100 0.0000
160 0.0060 nan 0.0100 0.0000
180 0.0048 nan 0.0100 0.0000
200 0.0038 nan 0.0100 0.0000
- Fold07: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold07: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0424 nan 0.0100 0.0003
2 0.0417 nan 0.0100 0.0005
3 0.0411 nan 0.0100 0.0006
4 0.0405 nan 0.0100 0.0003
5 0.0398 nan 0.0100 0.0006
6 0.0390 nan 0.0100 0.0006
7 0.0385 nan 0.0100 -0.0000
8 0.0380 nan 0.0100 0.0006
9 0.0375 nan 0.0100 0.0004
10 0.0369 nan 0.0100 0.0004
20 0.0323 nan 0.0100 0.0002
40 0.0245 nan 0.0100 0.0001
60 0.0189 nan 0.0100 0.0002
80 0.0148 nan 0.0100 0.0001
100 0.0115 nan 0.0100 0.0002
120 0.0092 nan 0.0100 0.0001
140 0.0075 nan 0.0100 0.0000
160 0.0062 nan 0.0100 0.0000
180 0.0051 nan 0.0100 0.0000
200 0.0042 nan 0.0100 0.0000
- Fold07: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold07: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0425 nan 0.0100 0.0004
2 0.0419 nan 0.0100 0.0005
3 0.0414 nan 0.0100 0.0004
4 0.0410 nan 0.0100 0.0003
5 0.0405 nan 0.0100 0.0005
6 0.0400 nan 0.0100 0.0005
7 0.0396 nan 0.0100 0.0005
8 0.0391 nan 0.0100 0.0002
9 0.0385 nan 0.0100 0.0005
10 0.0379 nan 0.0100 0.0005
20 0.0337 nan 0.0100 0.0003
40 0.0273 nan 0.0100 -0.0000
60 0.0231 nan 0.0100 -0.0000
80 0.0193 nan 0.0100 0.0002
100 0.0164 nan 0.0100 0.0001
120 0.0139 nan 0.0100 0.0001
140 0.0120 nan 0.0100 0.0000
160 0.0105 nan 0.0100 -0.0000
180 0.0093 nan 0.0100 0.0000
200 0.0082 nan 0.0100 0.0000
- Fold07: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold07: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0422 nan 0.0100 0.0005
2 0.0417 nan 0.0100 0.0001
3 0.0413 nan 0.0100 0.0002
4 0.0407 nan 0.0100 0.0005
5 0.0400 nan 0.0100 0.0003
6 0.0395 nan 0.0100 0.0002
7 0.0386 nan 0.0100 0.0005
8 0.0382 nan 0.0100 0.0003
9 0.0376 nan 0.0100 0.0006
10 0.0371 nan 0.0100 0.0003
20 0.0323 nan 0.0100 0.0004
40 0.0243 nan 0.0100 0.0002
60 0.0182 nan 0.0100 0.0003
80 0.0138 nan 0.0100 0.0001
100 0.0104 nan 0.0100 0.0002
120 0.0081 nan 0.0100 0.0000
140 0.0061 nan 0.0100 0.0001
160 0.0048 nan 0.0100 0.0000
180 0.0038 nan 0.0100 0.0000
200 0.0032 nan 0.0100 0.0000
- Fold07: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold07: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0424 nan 0.0100 0.0004
2 0.0418 nan 0.0100 0.0006
3 0.0414 nan 0.0100 0.0004
4 0.0407 nan 0.0100 0.0006
5 0.0400 nan 0.0100 0.0006
6 0.0392 nan 0.0100 0.0005
7 0.0387 nan 0.0100 0.0005
8 0.0383 nan 0.0100 0.0005
9 0.0380 nan 0.0100 0.0000
10 0.0375 nan 0.0100 0.0001
20 0.0322 nan 0.0100 0.0002
40 0.0249 nan 0.0100 0.0002
60 0.0195 nan 0.0100 -0.0000
80 0.0152 nan 0.0100 0.0001
100 0.0115 nan 0.0100 0.0002
120 0.0092 nan 0.0100 0.0000
140 0.0076 nan 0.0100 0.0001
160 0.0061 nan 0.0100 -0.0000
180 0.0048 nan 0.0100 0.0000
200 0.0039 nan 0.0100 0.0000
- Fold07: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold07: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0425 nan 0.0100 0.0004
2 0.0419 nan 0.0100 0.0002
3 0.0414 nan 0.0100 0.0003
4 0.0409 nan 0.0100 0.0002
5 0.0403 nan 0.0100 0.0005
6 0.0398 nan 0.0100 0.0003
7 0.0394 nan 0.0100 0.0005
8 0.0390 nan 0.0100 0.0001
9 0.0386 nan 0.0100 0.0003
10 0.0382 nan 0.0100 0.0001
20 0.0341 nan 0.0100 0.0003
40 0.0279 nan 0.0100 0.0001
60 0.0226 nan 0.0100 0.0001
80 0.0186 nan 0.0100 0.0002
100 0.0155 nan 0.0100 0.0001
120 0.0135 nan 0.0100 0.0000
140 0.0118 nan 0.0100 -0.0000
160 0.0106 nan 0.0100 0.0001
180 0.0092 nan 0.0100 0.0000
200 0.0082 nan 0.0100 -0.0000
- Fold07: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold07: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0418 nan 0.0500 0.0009
2 0.0395 nan 0.0500 0.0017
3 0.0376 nan 0.0500 0.0011
4 0.0356 nan 0.0500 0.0015
5 0.0331 nan 0.0500 0.0021
6 0.0313 nan 0.0500 0.0016
7 0.0300 nan 0.0500 0.0008
8 0.0284 nan 0.0500 0.0012
9 0.0268 nan 0.0500 0.0016
10 0.0249 nan 0.0500 0.0012
20 0.0152 nan 0.0500 0.0008
40 0.0071 nan 0.0500 0.0003
60 0.0036 nan 0.0500 0.0000
80 0.0016 nan 0.0500 0.0001
100 0.0009 nan 0.0500 0.0000
120 0.0006 nan 0.0500 -0.0000
140 0.0004 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold07: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold07: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0408 nan 0.0500 0.0018
2 0.0382 nan 0.0500 0.0024
3 0.0369 nan 0.0500 0.0010
4 0.0344 nan 0.0500 0.0020
5 0.0324 nan 0.0500 0.0019
6 0.0312 nan 0.0500 0.0016
7 0.0303 nan 0.0500 -0.0001
8 0.0284 nan 0.0500 0.0018
9 0.0267 nan 0.0500 0.0003
10 0.0253 nan 0.0500 0.0016
20 0.0142 nan 0.0500 0.0009
40 0.0061 nan 0.0500 0.0002
60 0.0029 nan 0.0500 0.0000
80 0.0016 nan 0.0500 -0.0000
100 0.0010 nan 0.0500 0.0000
120 0.0007 nan 0.0500 -0.0000
140 0.0004 nan 0.0500 0.0000
160 0.0003 nan 0.0500 -0.0000
180 0.0002 nan 0.0500 0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold07: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold07: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0405 nan 0.0500 0.0013
2 0.0378 nan 0.0500 0.0017
3 0.0358 nan 0.0500 0.0011
4 0.0336 nan 0.0500 0.0006
5 0.0317 nan 0.0500 0.0020
6 0.0297 nan 0.0500 0.0018
7 0.0278 nan 0.0500 0.0019
8 0.0262 nan 0.0500 0.0010
9 0.0253 nan 0.0500 0.0005
10 0.0239 nan 0.0500 0.0013
20 0.0150 nan 0.0500 0.0006
40 0.0085 nan 0.0500 0.0000
60 0.0049 nan 0.0500 0.0001
80 0.0030 nan 0.0500 0.0001
100 0.0024 nan 0.0500 -0.0000
120 0.0017 nan 0.0500 0.0000
140 0.0012 nan 0.0500 -0.0000
160 0.0009 nan 0.0500 -0.0000
180 0.0007 nan 0.0500 0.0000
200 0.0005 nan 0.0500 -0.0000
- Fold07: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold07: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0399 nan 0.0500 0.0024
2 0.0368 nan 0.0500 0.0030
3 0.0338 nan 0.0500 0.0025
4 0.0307 nan 0.0500 0.0012
5 0.0284 nan 0.0500 0.0024
6 0.0261 nan 0.0500 0.0010
7 0.0244 nan 0.0500 0.0013
8 0.0228 nan 0.0500 0.0013
9 0.0217 nan 0.0500 0.0008
10 0.0208 nan 0.0500 0.0003
20 0.0115 nan 0.0500 0.0001
40 0.0037 nan 0.0500 0.0001
60 0.0015 nan 0.0500 -0.0000
80 0.0006 nan 0.0500 -0.0000
100 0.0003 nan 0.0500 -0.0000
120 0.0001 nan 0.0500 0.0000
140 0.0001 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold07: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold07: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0404 nan 0.0500 0.0019
2 0.0375 nan 0.0500 0.0027
3 0.0359 nan 0.0500 0.0009
4 0.0332 nan 0.0500 0.0020
5 0.0326 nan 0.0500 -0.0011
6 0.0308 nan 0.0500 0.0016
7 0.0297 nan 0.0500 0.0005
8 0.0287 nan 0.0500 0.0004
9 0.0269 nan 0.0500 0.0004
10 0.0253 nan 0.0500 0.0005
20 0.0131 nan 0.0500 0.0004
40 0.0054 nan 0.0500 0.0002
60 0.0022 nan 0.0500 0.0001
80 0.0013 nan 0.0500 -0.0000
100 0.0008 nan 0.0500 0.0000
120 0.0005 nan 0.0500 0.0000
140 0.0003 nan 0.0500 0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold07: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold07: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0412 nan 0.0500 0.0017
2 0.0386 nan 0.0500 0.0028
3 0.0361 nan 0.0500 0.0022
4 0.0356 nan 0.0500 -0.0008
5 0.0335 nan 0.0500 0.0008
6 0.0321 nan 0.0500 0.0017
7 0.0304 nan 0.0500 0.0018
8 0.0285 nan 0.0500 0.0018
9 0.0269 nan 0.0500 0.0012
10 0.0256 nan 0.0500 0.0014
20 0.0163 nan 0.0500 0.0003
40 0.0082 nan 0.0500 0.0003
60 0.0049 nan 0.0500 0.0000
80 0.0034 nan 0.0500 0.0001
100 0.0021 nan 0.0500 -0.0000
120 0.0015 nan 0.0500 0.0000
140 0.0011 nan 0.0500 -0.0000
160 0.0009 nan 0.0500 -0.0000
180 0.0007 nan 0.0500 -0.0000
200 0.0005 nan 0.0500 -0.0000
- Fold07: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold07: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0396 nan 0.0500 0.0030
2 0.0375 nan 0.0500 0.0009
3 0.0343 nan 0.0500 0.0026
4 0.0331 nan 0.0500 0.0013
5 0.0299 nan 0.0500 0.0036
6 0.0276 nan 0.0500 0.0020
7 0.0268 nan 0.0500 -0.0004
8 0.0257 nan 0.0500 0.0005
9 0.0241 nan 0.0500 0.0005
10 0.0221 nan 0.0500 0.0011
20 0.0105 nan 0.0500 0.0001
40 0.0035 nan 0.0500 0.0002
60 0.0013 nan 0.0500 -0.0001
80 0.0006 nan 0.0500 0.0000
100 0.0002 nan 0.0500 -0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0000 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold07: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold07: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0392 nan 0.0500 0.0025
2 0.0359 nan 0.0500 0.0019
3 0.0335 nan 0.0500 0.0024
4 0.0307 nan 0.0500 0.0018
5 0.0280 nan 0.0500 0.0009
6 0.0263 nan 0.0500 0.0015
7 0.0243 nan 0.0500 0.0015
8 0.0234 nan 0.0500 0.0002
9 0.0222 nan 0.0500 0.0010
10 0.0203 nan 0.0500 0.0009
20 0.0102 nan 0.0500 0.0007
40 0.0036 nan 0.0500 0.0001
60 0.0018 nan 0.0500 -0.0000
80 0.0010 nan 0.0500 0.0000
100 0.0005 nan 0.0500 -0.0000
120 0.0003 nan 0.0500 -0.0000
140 0.0002 nan 0.0500 -0.0000
160 0.0001 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 0.0000
- Fold07: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold07: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0403 nan 0.0500 0.0020
2 0.0377 nan 0.0500 0.0028
3 0.0353 nan 0.0500 0.0015
4 0.0335 nan 0.0500 0.0002
5 0.0322 nan 0.0500 0.0001
6 0.0299 nan 0.0500 0.0020
7 0.0287 nan 0.0500 -0.0003
8 0.0272 nan 0.0500 0.0015
9 0.0256 nan 0.0500 0.0015
10 0.0248 nan 0.0500 0.0000
20 0.0155 nan 0.0500 0.0005
40 0.0082 nan 0.0500 0.0002
60 0.0050 nan 0.0500 0.0001
80 0.0033 nan 0.0500 -0.0001
100 0.0021 nan 0.0500 -0.0000
120 0.0017 nan 0.0500 0.0000
140 0.0012 nan 0.0500 0.0000
160 0.0009 nan 0.0500 -0.0000
180 0.0007 nan 0.0500 0.0000
200 0.0006 nan 0.0500 -0.0000
- Fold07: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold07: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0381 nan 0.1000 0.0055
2 0.0330 nan 0.1000 0.0040
3 0.0298 nan 0.1000 0.0021
4 0.0269 nan 0.1000 0.0019
5 0.0242 nan 0.1000 0.0006
6 0.0218 nan 0.1000 0.0020
7 0.0203 nan 0.1000 -0.0001
8 0.0185 nan 0.1000 0.0013
9 0.0167 nan 0.1000 0.0014
10 0.0155 nan 0.1000 0.0014
20 0.0066 nan 0.1000 0.0003
40 0.0018 nan 0.1000 0.0000
60 0.0006 nan 0.1000 0.0000
80 0.0002 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 0.0000
120 0.0000 nan 0.1000 0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold07: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold07: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0385 nan 0.1000 0.0040
2 0.0338 nan 0.1000 0.0019
3 0.0303 nan 0.1000 0.0039
4 0.0259 nan 0.1000 0.0033
5 0.0251 nan 0.1000 -0.0004
6 0.0225 nan 0.1000 0.0030
7 0.0198 nan 0.1000 0.0014
8 0.0179 nan 0.1000 -0.0003
9 0.0161 nan 0.1000 0.0019
10 0.0141 nan 0.1000 0.0016
20 0.0060 nan 0.1000 0.0004
40 0.0016 nan 0.1000 -0.0000
60 0.0007 nan 0.1000 -0.0000
80 0.0003 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold07: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold07: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0379 nan 0.1000 0.0050
2 0.0347 nan 0.1000 0.0032
3 0.0312 nan 0.1000 0.0031
4 0.0277 nan 0.1000 0.0017
5 0.0249 nan 0.1000 0.0013
6 0.0226 nan 0.1000 0.0021
7 0.0204 nan 0.1000 0.0017
8 0.0183 nan 0.1000 0.0023
9 0.0165 nan 0.1000 0.0005
10 0.0150 nan 0.1000 0.0016
20 0.0075 nan 0.1000 -0.0003
40 0.0033 nan 0.1000 0.0000
60 0.0017 nan 0.1000 -0.0001
80 0.0010 nan 0.1000 -0.0001
100 0.0006 nan 0.1000 -0.0000
120 0.0004 nan 0.1000 0.0000
140 0.0002 nan 0.1000 0.0000
160 0.0002 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold07: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold07: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0363 nan 0.1000 0.0054
2 0.0310 nan 0.1000 0.0055
3 0.0288 nan 0.1000 0.0019
4 0.0262 nan 0.1000 0.0011
5 0.0235 nan 0.1000 0.0010
6 0.0208 nan 0.1000 0.0019
7 0.0181 nan 0.1000 0.0018
8 0.0152 nan 0.1000 0.0016
9 0.0139 nan 0.1000 0.0005
10 0.0122 nan 0.1000 0.0007
20 0.0034 nan 0.1000 0.0001
40 0.0005 nan 0.1000 -0.0000
60 0.0001 nan 0.1000 0.0000
80 0.0000 nan 0.1000 0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold07: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold07: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0369 nan 0.1000 0.0059
2 0.0337 nan 0.1000 0.0038
3 0.0321 nan 0.1000 -0.0004
4 0.0278 nan 0.1000 0.0033
5 0.0244 nan 0.1000 0.0034
6 0.0225 nan 0.1000 0.0020
7 0.0201 nan 0.1000 0.0023
8 0.0178 nan 0.1000 0.0020
9 0.0163 nan 0.1000 0.0013
10 0.0139 nan 0.1000 0.0010
20 0.0057 nan 0.1000 -0.0001
40 0.0012 nan 0.1000 -0.0000
60 0.0004 nan 0.1000 0.0000
80 0.0002 nan 0.1000 0.0000
100 0.0001 nan 0.1000 0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold07: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold07: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0377 nan 0.1000 0.0037
2 0.0342 nan 0.1000 0.0026
3 0.0321 nan 0.1000 0.0018
4 0.0289 nan 0.1000 0.0023
5 0.0252 nan 0.1000 0.0034
6 0.0237 nan 0.1000 0.0005
7 0.0220 nan 0.1000 0.0010
8 0.0202 nan 0.1000 0.0008
9 0.0186 nan 0.1000 0.0009
10 0.0170 nan 0.1000 0.0001
20 0.0079 nan 0.1000 0.0003
40 0.0029 nan 0.1000 0.0000
60 0.0016 nan 0.1000 0.0000
80 0.0008 nan 0.1000 0.0000
100 0.0004 nan 0.1000 0.0000
120 0.0002 nan 0.1000 0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold07: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold07: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0369 nan 0.1000 0.0011
2 0.0315 nan 0.1000 0.0048
3 0.0286 nan 0.1000 0.0030
4 0.0235 nan 0.1000 0.0029
5 0.0211 nan 0.1000 0.0002
6 0.0184 nan 0.1000 0.0028
7 0.0167 nan 0.1000 0.0008
8 0.0152 nan 0.1000 0.0013
9 0.0138 nan 0.1000 0.0006
10 0.0120 nan 0.1000 0.0002
20 0.0028 nan 0.1000 0.0003
40 0.0005 nan 0.1000 -0.0000
60 0.0001 nan 0.1000 0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 0.0000
140 0.0000 nan 0.1000 0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold07: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold07: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0362 nan 0.1000 0.0073
2 0.0290 nan 0.1000 0.0046
3 0.0254 nan 0.1000 0.0023
4 0.0208 nan 0.1000 0.0031
5 0.0182 nan 0.1000 0.0028
6 0.0170 nan 0.1000 0.0002
7 0.0141 nan 0.1000 0.0019
8 0.0122 nan 0.1000 0.0013
9 0.0105 nan 0.1000 0.0013
10 0.0091 nan 0.1000 0.0010
20 0.0035 nan 0.1000 0.0001
40 0.0009 nan 0.1000 -0.0000
60 0.0003 nan 0.1000 -0.0000
80 0.0002 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold07: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold07: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0419 nan 0.1000 -0.0023
2 0.0360 nan 0.1000 0.0055
3 0.0314 nan 0.1000 0.0039
4 0.0282 nan 0.1000 0.0033
5 0.0262 nan 0.1000 0.0016
6 0.0250 nan 0.1000 0.0008
7 0.0236 nan 0.1000 0.0012
8 0.0213 nan 0.1000 0.0014
9 0.0188 nan 0.1000 0.0020
10 0.0182 nan 0.1000 0.0004
20 0.0099 nan 0.1000 -0.0001
40 0.0034 nan 0.1000 0.0001
60 0.0014 nan 0.1000 -0.0000
80 0.0008 nan 0.1000 0.0000
100 0.0005 nan 0.1000 0.0000
120 0.0003 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold07: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold08: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0437 nan 0.0100 0.0005
2 0.0433 nan 0.0100 0.0005
3 0.0428 nan 0.0100 0.0004
4 0.0422 nan 0.0100 0.0006
5 0.0418 nan 0.0100 0.0002
6 0.0412 nan 0.0100 0.0004
7 0.0408 nan 0.0100 0.0006
8 0.0402 nan 0.0100 0.0004
9 0.0398 nan 0.0100 0.0004
10 0.0393 nan 0.0100 0.0006
20 0.0350 nan 0.0100 0.0004
40 0.0274 nan 0.0100 0.0002
60 0.0216 nan 0.0100 0.0002
80 0.0176 nan 0.0100 0.0002
100 0.0142 nan 0.0100 0.0001
120 0.0117 nan 0.0100 -0.0000
140 0.0097 nan 0.0100 0.0001
160 0.0082 nan 0.0100 0.0000
180 0.0069 nan 0.0100 0.0001
200 0.0057 nan 0.0100 0.0001
- Fold08: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold08: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0440 nan 0.0100 0.0004
2 0.0435 nan 0.0100 0.0006
3 0.0429 nan 0.0100 0.0006
4 0.0423 nan 0.0100 0.0004
5 0.0420 nan 0.0100 -0.0001
6 0.0415 nan 0.0100 0.0003
7 0.0409 nan 0.0100 0.0006
8 0.0406 nan 0.0100 0.0001
9 0.0400 nan 0.0100 0.0005
10 0.0395 nan 0.0100 0.0004
20 0.0349 nan 0.0100 0.0006
40 0.0279 nan 0.0100 0.0002
60 0.0225 nan 0.0100 0.0002
80 0.0184 nan 0.0100 0.0001
100 0.0155 nan 0.0100 0.0001
120 0.0131 nan 0.0100 -0.0001
140 0.0109 nan 0.0100 0.0000
160 0.0092 nan 0.0100 0.0000
180 0.0078 nan 0.0100 0.0000
200 0.0067 nan 0.0100 0.0000
- Fold08: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold08: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0437 nan 0.0100 0.0007
2 0.0430 nan 0.0100 0.0006
3 0.0425 nan 0.0100 0.0006
4 0.0418 nan 0.0100 0.0006
5 0.0413 nan 0.0100 0.0006
6 0.0406 nan 0.0100 0.0006
7 0.0402 nan 0.0100 0.0000
8 0.0396 nan 0.0100 0.0006
9 0.0391 nan 0.0100 0.0004
10 0.0387 nan 0.0100 0.0003
20 0.0348 nan 0.0100 0.0004
40 0.0279 nan 0.0100 0.0004
60 0.0225 nan 0.0100 0.0001
80 0.0188 nan 0.0100 0.0001
100 0.0157 nan 0.0100 0.0001
120 0.0136 nan 0.0100 0.0000
140 0.0120 nan 0.0100 0.0000
160 0.0106 nan 0.0100 0.0001
180 0.0092 nan 0.0100 0.0001
200 0.0083 nan 0.0100 -0.0000
- Fold08: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold08: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0438 nan 0.0100 0.0006
2 0.0434 nan 0.0100 0.0002
3 0.0429 nan 0.0100 0.0003
4 0.0419 nan 0.0100 0.0009
5 0.0414 nan 0.0100 0.0005
6 0.0407 nan 0.0100 0.0004
7 0.0401 nan 0.0100 0.0007
8 0.0394 nan 0.0100 0.0005
9 0.0388 nan 0.0100 0.0002
10 0.0384 nan 0.0100 0.0001
20 0.0334 nan 0.0100 0.0004
40 0.0246 nan 0.0100 0.0000
60 0.0188 nan 0.0100 -0.0000
80 0.0146 nan 0.0100 0.0001
100 0.0112 nan 0.0100 0.0001
120 0.0089 nan 0.0100 0.0001
140 0.0070 nan 0.0100 0.0001
160 0.0055 nan 0.0100 0.0000
180 0.0046 nan 0.0100 0.0000
200 0.0037 nan 0.0100 0.0000
- Fold08: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold08: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0438 nan 0.0100 0.0006
2 0.0431 nan 0.0100 0.0007
3 0.0424 nan 0.0100 0.0006
4 0.0418 nan 0.0100 0.0006
5 0.0411 nan 0.0100 0.0004
6 0.0405 nan 0.0100 0.0005
7 0.0399 nan 0.0100 0.0006
8 0.0393 nan 0.0100 0.0005
9 0.0388 nan 0.0100 0.0005
10 0.0383 nan 0.0100 0.0002
20 0.0330 nan 0.0100 0.0004
40 0.0254 nan 0.0100 0.0003
60 0.0194 nan 0.0100 0.0003
80 0.0153 nan 0.0100 0.0001
100 0.0122 nan 0.0100 0.0001
120 0.0097 nan 0.0100 -0.0000
140 0.0077 nan 0.0100 0.0000
160 0.0062 nan 0.0100 0.0001
180 0.0050 nan 0.0100 0.0000
200 0.0041 nan 0.0100 0.0000
- Fold08: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold08: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0439 nan 0.0100 0.0005
2 0.0435 nan 0.0100 0.0005
3 0.0429 nan 0.0100 0.0006
4 0.0425 nan 0.0100 0.0003
5 0.0421 nan 0.0100 0.0003
6 0.0416 nan 0.0100 0.0006
7 0.0410 nan 0.0100 0.0003
8 0.0406 nan 0.0100 0.0003
9 0.0403 nan 0.0100 0.0003
10 0.0398 nan 0.0100 0.0005
20 0.0357 nan 0.0100 0.0004
40 0.0284 nan 0.0100 0.0000
60 0.0230 nan 0.0100 0.0002
80 0.0191 nan 0.0100 0.0002
100 0.0163 nan 0.0100 0.0001
120 0.0138 nan 0.0100 0.0001
140 0.0119 nan 0.0100 0.0000
160 0.0103 nan 0.0100 0.0000
180 0.0091 nan 0.0100 -0.0000
200 0.0082 nan 0.0100 0.0000
- Fold08: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold08: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0437 nan 0.0100 0.0007
2 0.0431 nan 0.0100 0.0003
3 0.0427 nan 0.0100 0.0001
4 0.0420 nan 0.0100 0.0007
5 0.0412 nan 0.0100 0.0006
6 0.0403 nan 0.0100 0.0008
7 0.0400 nan 0.0100 0.0001
8 0.0395 nan 0.0100 0.0005
9 0.0388 nan 0.0100 0.0005
10 0.0381 nan 0.0100 0.0006
20 0.0331 nan 0.0100 0.0005
40 0.0249 nan 0.0100 0.0004
60 0.0182 nan 0.0100 0.0001
80 0.0140 nan 0.0100 0.0001
100 0.0108 nan 0.0100 0.0001
120 0.0082 nan 0.0100 0.0001
140 0.0064 nan 0.0100 0.0001
160 0.0051 nan 0.0100 0.0000
180 0.0040 nan 0.0100 0.0000
200 0.0032 nan 0.0100 0.0000
- Fold08: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold08: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0438 nan 0.0100 0.0002
2 0.0431 nan 0.0100 0.0007
3 0.0425 nan 0.0100 0.0003
4 0.0418 nan 0.0100 0.0008
5 0.0412 nan 0.0100 0.0006
6 0.0405 nan 0.0100 0.0006
7 0.0399 nan 0.0100 0.0005
8 0.0394 nan 0.0100 0.0005
9 0.0390 nan 0.0100 0.0004
10 0.0383 nan 0.0100 0.0007
20 0.0329 nan 0.0100 0.0004
40 0.0251 nan 0.0100 0.0002
60 0.0194 nan 0.0100 0.0001
80 0.0151 nan 0.0100 0.0001
100 0.0117 nan 0.0100 0.0001
120 0.0093 nan 0.0100 0.0001
140 0.0074 nan 0.0100 0.0000
160 0.0059 nan 0.0100 0.0000
180 0.0048 nan 0.0100 0.0000
200 0.0040 nan 0.0100 -0.0000
- Fold08: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold08: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0443 nan 0.0100 -0.0003
2 0.0437 nan 0.0100 0.0004
3 0.0430 nan 0.0100 0.0005
4 0.0424 nan 0.0100 0.0006
5 0.0417 nan 0.0100 0.0006
6 0.0412 nan 0.0100 0.0006
7 0.0407 nan 0.0100 0.0004
8 0.0400 nan 0.0100 0.0004
9 0.0394 nan 0.0100 0.0006
10 0.0390 nan 0.0100 0.0003
20 0.0347 nan 0.0100 0.0004
40 0.0274 nan 0.0100 0.0002
60 0.0225 nan 0.0100 0.0003
80 0.0188 nan 0.0100 0.0002
100 0.0157 nan 0.0100 0.0001
120 0.0133 nan 0.0100 0.0000
140 0.0114 nan 0.0100 0.0000
160 0.0100 nan 0.0100 0.0001
180 0.0087 nan 0.0100 0.0000
200 0.0078 nan 0.0100 0.0000
- Fold08: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold08: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0414 nan 0.0500 0.0028
2 0.0388 nan 0.0500 0.0023
3 0.0372 nan 0.0500 0.0010
4 0.0353 nan 0.0500 0.0014
5 0.0334 nan 0.0500 0.0017
6 0.0312 nan 0.0500 0.0020
7 0.0303 nan 0.0500 -0.0003
8 0.0281 nan 0.0500 0.0020
9 0.0264 nan 0.0500 0.0017
10 0.0258 nan 0.0500 0.0000
20 0.0144 nan 0.0500 0.0000
40 0.0058 nan 0.0500 0.0002
60 0.0029 nan 0.0500 0.0001
80 0.0016 nan 0.0500 -0.0001
100 0.0008 nan 0.0500 0.0000
120 0.0005 nan 0.0500 0.0000
140 0.0003 nan 0.0500 0.0000
160 0.0002 nan 0.0500 0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold08: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold08: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0413 nan 0.0500 0.0034
2 0.0388 nan 0.0500 0.0024
3 0.0360 nan 0.0500 0.0026
4 0.0334 nan 0.0500 0.0024
5 0.0313 nan 0.0500 0.0020
6 0.0295 nan 0.0500 0.0014
7 0.0275 nan 0.0500 0.0020
8 0.0263 nan 0.0500 0.0003
9 0.0248 nan 0.0500 0.0016
10 0.0236 nan 0.0500 0.0013
20 0.0138 nan 0.0500 0.0008
40 0.0064 nan 0.0500 0.0003
60 0.0033 nan 0.0500 0.0001
80 0.0021 nan 0.0500 -0.0000
100 0.0013 nan 0.0500 -0.0000
120 0.0008 nan 0.0500 -0.0000
140 0.0006 nan 0.0500 0.0000
160 0.0004 nan 0.0500 -0.0000
180 0.0002 nan 0.0500 0.0000
200 0.0002 nan 0.0500 -0.0000
- Fold08: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold08: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0419 nan 0.0500 0.0028
2 0.0386 nan 0.0500 0.0027
3 0.0361 nan 0.0500 0.0027
4 0.0339 nan 0.0500 0.0022
5 0.0322 nan 0.0500 0.0007
6 0.0304 nan 0.0500 0.0017
7 0.0289 nan 0.0500 0.0017
8 0.0269 nan 0.0500 0.0017
9 0.0252 nan 0.0500 0.0017
10 0.0243 nan 0.0500 0.0002
20 0.0156 nan 0.0500 0.0003
40 0.0089 nan 0.0500 0.0000
60 0.0055 nan 0.0500 0.0002
80 0.0035 nan 0.0500 -0.0001
100 0.0022 nan 0.0500 -0.0001
120 0.0016 nan 0.0500 -0.0000
140 0.0012 nan 0.0500 -0.0000
160 0.0009 nan 0.0500 -0.0000
180 0.0006 nan 0.0500 -0.0000
200 0.0005 nan 0.0500 0.0000
- Fold08: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold08: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0419 nan 0.0500 0.0004
2 0.0385 nan 0.0500 0.0031
3 0.0367 nan 0.0500 0.0014
4 0.0334 nan 0.0500 0.0023
5 0.0310 nan 0.0500 0.0018
6 0.0295 nan 0.0500 0.0014
7 0.0274 nan 0.0500 0.0020
8 0.0258 nan 0.0500 0.0015
9 0.0242 nan 0.0500 0.0012
10 0.0228 nan 0.0500 0.0006
20 0.0121 nan 0.0500 0.0008
40 0.0044 nan 0.0500 0.0004
60 0.0016 nan 0.0500 0.0000
80 0.0007 nan 0.0500 -0.0000
100 0.0003 nan 0.0500 0.0000
120 0.0002 nan 0.0500 -0.0000
140 0.0001 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold08: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold08: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0410 nan 0.0500 0.0035
2 0.0381 nan 0.0500 0.0020
3 0.0358 nan 0.0500 0.0016
4 0.0344 nan 0.0500 0.0014
5 0.0317 nan 0.0500 0.0020
6 0.0302 nan 0.0500 0.0011
7 0.0279 nan 0.0500 0.0026
8 0.0258 nan 0.0500 0.0011
9 0.0245 nan 0.0500 0.0015
10 0.0232 nan 0.0500 0.0013
20 0.0111 nan 0.0500 0.0008
40 0.0039 nan 0.0500 0.0000
60 0.0020 nan 0.0500 0.0001
80 0.0009 nan 0.0500 -0.0000
100 0.0005 nan 0.0500 -0.0000
120 0.0003 nan 0.0500 -0.0000
140 0.0002 nan 0.0500 -0.0000
160 0.0001 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold08: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold08: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0421 nan 0.0500 0.0023
2 0.0390 nan 0.0500 0.0026
3 0.0365 nan 0.0500 0.0027
4 0.0345 nan 0.0500 0.0021
5 0.0334 nan 0.0500 0.0007
6 0.0310 nan 0.0500 0.0021
7 0.0290 nan 0.0500 0.0006
8 0.0274 nan 0.0500 0.0018
9 0.0259 nan 0.0500 0.0008
10 0.0241 nan 0.0500 0.0013
20 0.0155 nan 0.0500 0.0002
40 0.0074 nan 0.0500 0.0003
60 0.0043 nan 0.0500 0.0001
80 0.0025 nan 0.0500 0.0000
100 0.0019 nan 0.0500 0.0000
120 0.0014 nan 0.0500 -0.0000
140 0.0010 nan 0.0500 0.0000
160 0.0007 nan 0.0500 0.0000
180 0.0005 nan 0.0500 0.0000
200 0.0004 nan 0.0500 -0.0000
- Fold08: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold08: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0401 nan 0.0500 0.0041
2 0.0376 nan 0.0500 0.0003
3 0.0343 nan 0.0500 0.0019
4 0.0312 nan 0.0500 0.0017
5 0.0286 nan 0.0500 0.0011
6 0.0265 nan 0.0500 0.0012
7 0.0245 nan 0.0500 0.0014
8 0.0230 nan 0.0500 0.0011
9 0.0211 nan 0.0500 0.0012
10 0.0191 nan 0.0500 0.0015
20 0.0098 nan 0.0500 0.0005
40 0.0027 nan 0.0500 0.0001
60 0.0010 nan 0.0500 0.0000
80 0.0004 nan 0.0500 0.0000
100 0.0002 nan 0.0500 0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0000 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold08: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold08: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0422 nan 0.0500 0.0014
2 0.0401 nan 0.0500 0.0002
3 0.0383 nan 0.0500 0.0019
4 0.0364 nan 0.0500 0.0021
5 0.0339 nan 0.0500 0.0016
6 0.0319 nan 0.0500 0.0019
7 0.0299 nan 0.0500 0.0008
8 0.0280 nan 0.0500 0.0014
9 0.0270 nan 0.0500 0.0005
10 0.0258 nan 0.0500 0.0005
20 0.0125 nan 0.0500 0.0008
40 0.0038 nan 0.0500 0.0001
60 0.0019 nan 0.0500 -0.0000
80 0.0012 nan 0.0500 -0.0000
100 0.0008 nan 0.0500 -0.0000
120 0.0005 nan 0.0500 -0.0000
140 0.0003 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0002 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold08: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold08: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0411 nan 0.0500 0.0025
2 0.0392 nan 0.0500 0.0011
3 0.0361 nan 0.0500 0.0025
4 0.0331 nan 0.0500 0.0021
5 0.0312 nan 0.0500 0.0021
6 0.0287 nan 0.0500 0.0018
7 0.0267 nan 0.0500 0.0018
8 0.0257 nan 0.0500 0.0005
9 0.0249 nan 0.0500 -0.0005
10 0.0237 nan 0.0500 0.0014
20 0.0154 nan 0.0500 0.0007
40 0.0087 nan 0.0500 0.0002
60 0.0058 nan 0.0500 -0.0002
80 0.0039 nan 0.0500 -0.0000
100 0.0026 nan 0.0500 0.0000
120 0.0018 nan 0.0500 -0.0001
140 0.0014 nan 0.0500 -0.0000
160 0.0010 nan 0.0500 -0.0000
180 0.0009 nan 0.0500 -0.0000
200 0.0006 nan 0.0500 -0.0000
- Fold08: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold08: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0405 nan 0.1000 0.0036
2 0.0373 nan 0.1000 0.0014
3 0.0331 nan 0.1000 0.0030
4 0.0294 nan 0.1000 0.0039
5 0.0273 nan 0.1000 0.0008
6 0.0253 nan 0.1000 0.0019
7 0.0230 nan 0.1000 0.0027
8 0.0210 nan 0.1000 0.0016
9 0.0193 nan 0.1000 0.0018
10 0.0181 nan 0.1000 0.0004
20 0.0068 nan 0.1000 0.0001
40 0.0017 nan 0.1000 0.0000
60 0.0005 nan 0.1000 -0.0000
80 0.0002 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 0.0000
- Fold08: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold08: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0403 nan 0.1000 0.0007
2 0.0345 nan 0.1000 0.0054
3 0.0299 nan 0.1000 0.0021
4 0.0261 nan 0.1000 0.0039
5 0.0233 nan 0.1000 0.0032
6 0.0196 nan 0.1000 0.0027
7 0.0180 nan 0.1000 0.0015
8 0.0161 nan 0.1000 0.0017
9 0.0140 nan 0.1000 0.0006
10 0.0124 nan 0.1000 0.0011
20 0.0060 nan 0.1000 0.0005
40 0.0019 nan 0.1000 0.0001
60 0.0007 nan 0.1000 -0.0001
80 0.0003 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 0.0000
- Fold08: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold08: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0380 nan 0.1000 0.0062
2 0.0337 nan 0.1000 0.0029
3 0.0307 nan 0.1000 0.0028
4 0.0286 nan 0.1000 0.0003
5 0.0258 nan 0.1000 0.0015
6 0.0225 nan 0.1000 0.0011
7 0.0203 nan 0.1000 0.0011
8 0.0188 nan 0.1000 0.0013
9 0.0172 nan 0.1000 0.0006
10 0.0152 nan 0.1000 0.0018
20 0.0082 nan 0.1000 -0.0000
40 0.0041 nan 0.1000 0.0001
60 0.0019 nan 0.1000 0.0000
80 0.0010 nan 0.1000 -0.0001
100 0.0005 nan 0.1000 -0.0000
120 0.0003 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 0.0000
160 0.0002 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold08: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold08: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0400 nan 0.1000 0.0015
2 0.0351 nan 0.1000 0.0020
3 0.0303 nan 0.1000 0.0050
4 0.0277 nan 0.1000 0.0017
5 0.0244 nan 0.1000 0.0013
6 0.0211 nan 0.1000 0.0031
7 0.0192 nan 0.1000 0.0022
8 0.0167 nan 0.1000 0.0021
9 0.0143 nan 0.1000 0.0018
10 0.0139 nan 0.1000 -0.0018
20 0.0047 nan 0.1000 0.0001
40 0.0006 nan 0.1000 -0.0001
60 0.0001 nan 0.1000 0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold08: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold08: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0387 nan 0.1000 0.0068
2 0.0330 nan 0.1000 0.0045
3 0.0284 nan 0.1000 0.0027
4 0.0244 nan 0.1000 0.0038
5 0.0207 nan 0.1000 0.0034
6 0.0183 nan 0.1000 0.0020
7 0.0176 nan 0.1000 0.0008
8 0.0153 nan 0.1000 0.0011
9 0.0142 nan 0.1000 0.0010
10 0.0126 nan 0.1000 0.0007
20 0.0043 nan 0.1000 0.0003
40 0.0010 nan 0.1000 0.0000
60 0.0004 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold08: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold08: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0386 nan 0.1000 0.0054
2 0.0348 nan 0.1000 0.0029
3 0.0302 nan 0.1000 0.0041
4 0.0266 nan 0.1000 0.0035
5 0.0231 nan 0.1000 0.0023
6 0.0203 nan 0.1000 0.0023
7 0.0183 nan 0.1000 0.0020
8 0.0167 nan 0.1000 0.0012
9 0.0148 nan 0.1000 0.0015
10 0.0132 nan 0.1000 0.0010
20 0.0073 nan 0.1000 -0.0001
40 0.0025 nan 0.1000 0.0001
60 0.0013 nan 0.1000 -0.0001
80 0.0007 nan 0.1000 -0.0000
100 0.0004 nan 0.1000 0.0000
120 0.0003 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold08: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold08: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0368 nan 0.1000 0.0077
2 0.0309 nan 0.1000 0.0048
3 0.0264 nan 0.1000 0.0041
4 0.0220 nan 0.1000 0.0031
5 0.0185 nan 0.1000 0.0023
6 0.0163 nan 0.1000 0.0017
7 0.0137 nan 0.1000 0.0025
8 0.0119 nan 0.1000 0.0010
9 0.0101 nan 0.1000 0.0003
10 0.0085 nan 0.1000 0.0003
20 0.0028 nan 0.1000 0.0002
40 0.0004 nan 0.1000 -0.0000
60 0.0001 nan 0.1000 0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold08: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold08: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0384 nan 0.1000 0.0063
2 0.0313 nan 0.1000 0.0062
3 0.0267 nan 0.1000 0.0036
4 0.0243 nan 0.1000 0.0016
5 0.0214 nan 0.1000 0.0027
6 0.0200 nan 0.1000 0.0007
7 0.0174 nan 0.1000 0.0020
8 0.0168 nan 0.1000 -0.0007
9 0.0154 nan 0.1000 0.0009
10 0.0143 nan 0.1000 0.0011
20 0.0053 nan 0.1000 0.0007
40 0.0013 nan 0.1000 0.0001
60 0.0004 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold08: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold08: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0379 nan 0.1000 0.0057
2 0.0338 nan 0.1000 0.0035
3 0.0290 nan 0.1000 0.0035
4 0.0252 nan 0.1000 0.0032
5 0.0232 nan 0.1000 0.0016
6 0.0201 nan 0.1000 0.0020
7 0.0187 nan 0.1000 0.0009
8 0.0171 nan 0.1000 0.0007
9 0.0153 nan 0.1000 0.0014
10 0.0149 nan 0.1000 -0.0012
20 0.0083 nan 0.1000 0.0002
40 0.0036 nan 0.1000 -0.0001
60 0.0018 nan 0.1000 0.0001
80 0.0010 nan 0.1000 -0.0000
100 0.0005 nan 0.1000 -0.0000
120 0.0003 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold08: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold09: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0403 nan 0.0100 0.0005
2 0.0398 nan 0.0100 0.0004
3 0.0393 nan 0.0100 0.0005
4 0.0388 nan 0.0100 0.0004
5 0.0384 nan 0.0100 0.0003
6 0.0381 nan 0.0100 -0.0000
7 0.0378 nan 0.0100 0.0001
8 0.0373 nan 0.0100 0.0004
9 0.0369 nan 0.0100 0.0005
10 0.0363 nan 0.0100 0.0005
20 0.0322 nan 0.0100 0.0003
40 0.0258 nan 0.0100 0.0002
60 0.0207 nan 0.0100 -0.0001
80 0.0166 nan 0.0100 0.0002
100 0.0139 nan 0.0100 -0.0001
120 0.0114 nan 0.0100 0.0001
140 0.0097 nan 0.0100 0.0001
160 0.0082 nan 0.0100 0.0000
180 0.0069 nan 0.0100 0.0000
200 0.0058 nan 0.0100 0.0000
- Fold09: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold09: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0402 nan 0.0100 0.0006
2 0.0396 nan 0.0100 0.0005
3 0.0390 nan 0.0100 0.0005
4 0.0385 nan 0.0100 0.0004
5 0.0380 nan 0.0100 0.0005
6 0.0376 nan 0.0100 0.0004
7 0.0372 nan 0.0100 0.0004
8 0.0367 nan 0.0100 0.0004
9 0.0364 nan 0.0100 0.0002
10 0.0360 nan 0.0100 0.0004
20 0.0320 nan 0.0100 0.0003
40 0.0255 nan 0.0100 0.0002
60 0.0207 nan 0.0100 0.0002
80 0.0172 nan 0.0100 0.0001
100 0.0139 nan 0.0100 0.0000
120 0.0114 nan 0.0100 0.0000
140 0.0095 nan 0.0100 0.0001
160 0.0081 nan 0.0100 0.0001
180 0.0070 nan 0.0100 0.0000
200 0.0061 nan 0.0100 0.0000
- Fold09: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold09: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0405 nan 0.0100 0.0002
2 0.0401 nan 0.0100 0.0003
3 0.0396 nan 0.0100 0.0004
4 0.0391 nan 0.0100 0.0005
5 0.0387 nan 0.0100 0.0005
6 0.0382 nan 0.0100 0.0004
7 0.0378 nan 0.0100 0.0005
8 0.0375 nan 0.0100 0.0002
9 0.0371 nan 0.0100 0.0004
10 0.0367 nan 0.0100 0.0003
20 0.0323 nan 0.0100 0.0004
40 0.0264 nan 0.0100 0.0002
60 0.0213 nan 0.0100 0.0003
80 0.0180 nan 0.0100 0.0000
100 0.0148 nan 0.0100 0.0001
120 0.0128 nan 0.0100 0.0000
140 0.0112 nan 0.0100 0.0000
160 0.0100 nan 0.0100 0.0000
180 0.0088 nan 0.0100 0.0000
200 0.0078 nan 0.0100 -0.0000
- Fold09: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold09: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0402 nan 0.0100 0.0001
2 0.0395 nan 0.0100 0.0006
3 0.0392 nan 0.0100 0.0004
4 0.0385 nan 0.0100 0.0008
5 0.0381 nan 0.0100 0.0005
6 0.0376 nan 0.0100 0.0001
7 0.0371 nan 0.0100 0.0000
8 0.0368 nan 0.0100 0.0003
9 0.0363 nan 0.0100 0.0002
10 0.0357 nan 0.0100 0.0003
20 0.0311 nan 0.0100 0.0005
40 0.0238 nan 0.0100 0.0001
60 0.0185 nan 0.0100 0.0001
80 0.0142 nan 0.0100 0.0003
100 0.0107 nan 0.0100 0.0001
120 0.0088 nan 0.0100 -0.0000
140 0.0070 nan 0.0100 -0.0000
160 0.0056 nan 0.0100 0.0000
180 0.0045 nan 0.0100 0.0000
200 0.0037 nan 0.0100 0.0000
- Fold09: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold09: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0404 nan 0.0100 0.0005
2 0.0402 nan 0.0100 -0.0001
3 0.0396 nan 0.0100 0.0005
4 0.0391 nan 0.0100 0.0005
5 0.0390 nan 0.0100 -0.0002
6 0.0384 nan 0.0100 0.0004
7 0.0379 nan 0.0100 0.0006
8 0.0373 nan 0.0100 0.0005
9 0.0367 nan 0.0100 0.0002
10 0.0362 nan 0.0100 0.0005
20 0.0311 nan 0.0100 0.0003
40 0.0238 nan 0.0100 0.0003
60 0.0185 nan 0.0100 0.0002
80 0.0145 nan 0.0100 0.0002
100 0.0116 nan 0.0100 0.0001
120 0.0096 nan 0.0100 0.0001
140 0.0076 nan 0.0100 0.0001
160 0.0061 nan 0.0100 0.0000
180 0.0051 nan 0.0100 0.0001
200 0.0041 nan 0.0100 0.0000
- Fold09: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold09: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0404 nan 0.0100 0.0004
2 0.0400 nan 0.0100 0.0003
3 0.0394 nan 0.0100 0.0004
4 0.0390 nan 0.0100 0.0005
5 0.0388 nan 0.0100 0.0002
6 0.0384 nan 0.0100 0.0003
7 0.0378 nan 0.0100 0.0003
8 0.0374 nan 0.0100 0.0004
9 0.0371 nan 0.0100 0.0003
10 0.0367 nan 0.0100 0.0003
20 0.0323 nan 0.0100 0.0000
40 0.0256 nan 0.0100 0.0003
60 0.0213 nan 0.0100 0.0002
80 0.0174 nan 0.0100 0.0002
100 0.0144 nan 0.0100 0.0001
120 0.0121 nan 0.0100 0.0001
140 0.0107 nan 0.0100 0.0001
160 0.0092 nan 0.0100 -0.0000
180 0.0081 nan 0.0100 0.0000
200 0.0071 nan 0.0100 0.0000
- Fold09: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold09: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0403 nan 0.0100 0.0002
2 0.0396 nan 0.0100 0.0005
3 0.0390 nan 0.0100 0.0006
4 0.0382 nan 0.0100 0.0006
5 0.0376 nan 0.0100 0.0006
6 0.0370 nan 0.0100 0.0005
7 0.0363 nan 0.0100 0.0007
8 0.0356 nan 0.0100 0.0006
9 0.0352 nan 0.0100 0.0002
10 0.0348 nan 0.0100 0.0005
20 0.0303 nan 0.0100 0.0003
40 0.0231 nan 0.0100 0.0002
60 0.0177 nan 0.0100 0.0001
80 0.0134 nan 0.0100 0.0000
100 0.0102 nan 0.0100 0.0001
120 0.0080 nan 0.0100 0.0000
140 0.0061 nan 0.0100 0.0000
160 0.0048 nan 0.0100 0.0000
180 0.0038 nan 0.0100 0.0000
200 0.0031 nan 0.0100 -0.0000
- Fold09: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold09: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0404 nan 0.0100 0.0005
2 0.0398 nan 0.0100 0.0005
3 0.0392 nan 0.0100 0.0006
4 0.0387 nan 0.0100 0.0006
5 0.0380 nan 0.0100 0.0004
6 0.0374 nan 0.0100 0.0003
7 0.0369 nan 0.0100 0.0005
8 0.0365 nan 0.0100 0.0004
9 0.0361 nan 0.0100 0.0004
10 0.0356 nan 0.0100 0.0004
20 0.0312 nan 0.0100 0.0004
40 0.0236 nan 0.0100 0.0003
60 0.0186 nan 0.0100 0.0001
80 0.0146 nan 0.0100 0.0002
100 0.0116 nan 0.0100 0.0000
120 0.0093 nan 0.0100 0.0000
140 0.0073 nan 0.0100 0.0001
160 0.0060 nan 0.0100 -0.0000
180 0.0048 nan 0.0100 0.0000
200 0.0039 nan 0.0100 0.0000
- Fold09: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold09: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0404 nan 0.0100 0.0005
2 0.0400 nan 0.0100 0.0001
3 0.0395 nan 0.0100 0.0004
4 0.0390 nan 0.0100 0.0005
5 0.0385 nan 0.0100 0.0001
6 0.0380 nan 0.0100 0.0005
7 0.0376 nan 0.0100 0.0004
8 0.0371 nan 0.0100 0.0005
9 0.0366 nan 0.0100 0.0005
10 0.0362 nan 0.0100 0.0004
20 0.0319 nan 0.0100 0.0002
40 0.0255 nan 0.0100 0.0003
60 0.0209 nan 0.0100 0.0001
80 0.0175 nan 0.0100 0.0000
100 0.0147 nan 0.0100 0.0001
120 0.0126 nan 0.0100 0.0001
140 0.0108 nan 0.0100 0.0001
160 0.0093 nan 0.0100 0.0001
180 0.0082 nan 0.0100 -0.0000
200 0.0073 nan 0.0100 -0.0000
- Fold09: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold09: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0383 nan 0.0500 0.0025
2 0.0359 nan 0.0500 0.0023
3 0.0338 nan 0.0500 0.0018
4 0.0319 nan 0.0500 0.0009
5 0.0297 nan 0.0500 0.0014
6 0.0283 nan 0.0500 0.0011
7 0.0267 nan 0.0500 0.0019
8 0.0253 nan 0.0500 0.0014
9 0.0239 nan 0.0500 0.0013
10 0.0220 nan 0.0500 0.0017
20 0.0141 nan 0.0500 0.0003
40 0.0059 nan 0.0500 0.0002
60 0.0028 nan 0.0500 0.0000
80 0.0013 nan 0.0500 0.0000
100 0.0007 nan 0.0500 -0.0000
120 0.0005 nan 0.0500 -0.0000
140 0.0003 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold09: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold09: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0380 nan 0.0500 0.0023
2 0.0365 nan 0.0500 0.0014
3 0.0347 nan 0.0500 0.0019
4 0.0332 nan 0.0500 0.0014
5 0.0311 nan 0.0500 0.0021
6 0.0301 nan 0.0500 0.0003
7 0.0284 nan 0.0500 0.0017
8 0.0266 nan 0.0500 0.0017
9 0.0256 nan 0.0500 0.0002
10 0.0241 nan 0.0500 0.0014
20 0.0137 nan 0.0500 0.0005
40 0.0055 nan 0.0500 0.0002
60 0.0025 nan 0.0500 0.0000
80 0.0016 nan 0.0500 0.0000
100 0.0010 nan 0.0500 0.0000
120 0.0007 nan 0.0500 -0.0000
140 0.0004 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 0.0000
180 0.0002 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold09: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold09: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0380 nan 0.0500 0.0022
2 0.0357 nan 0.0500 0.0021
3 0.0341 nan 0.0500 0.0006
4 0.0318 nan 0.0500 0.0024
5 0.0303 nan 0.0500 0.0013
6 0.0290 nan 0.0500 0.0010
7 0.0277 nan 0.0500 0.0009
8 0.0266 nan 0.0500 0.0006
9 0.0250 nan 0.0500 0.0016
10 0.0236 nan 0.0500 0.0013
20 0.0149 nan 0.0500 0.0005
40 0.0067 nan 0.0500 0.0002
60 0.0040 nan 0.0500 0.0000
80 0.0026 nan 0.0500 0.0000
100 0.0018 nan 0.0500 -0.0000
120 0.0011 nan 0.0500 -0.0000
140 0.0008 nan 0.0500 0.0000
160 0.0006 nan 0.0500 -0.0000
180 0.0005 nan 0.0500 -0.0000
200 0.0004 nan 0.0500 -0.0000
- Fold09: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold09: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0383 nan 0.0500 0.0020
2 0.0367 nan 0.0500 0.0013
3 0.0344 nan 0.0500 0.0018
4 0.0317 nan 0.0500 0.0017
5 0.0293 nan 0.0500 0.0006
6 0.0275 nan 0.0500 0.0003
7 0.0261 nan 0.0500 0.0006
8 0.0249 nan 0.0500 0.0001
9 0.0230 nan 0.0500 0.0017
10 0.0212 nan 0.0500 0.0011
20 0.0112 nan 0.0500 0.0004
40 0.0040 nan 0.0500 0.0000
60 0.0017 nan 0.0500 -0.0000
80 0.0008 nan 0.0500 -0.0000
100 0.0004 nan 0.0500 -0.0000
120 0.0002 nan 0.0500 0.0000
140 0.0001 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold09: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold09: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0395 nan 0.0500 -0.0003
2 0.0371 nan 0.0500 0.0025
3 0.0340 nan 0.0500 0.0021
4 0.0311 nan 0.0500 0.0014
5 0.0287 nan 0.0500 0.0018
6 0.0267 nan 0.0500 0.0018
7 0.0254 nan 0.0500 0.0010
8 0.0244 nan 0.0500 0.0002
9 0.0232 nan 0.0500 -0.0003
10 0.0216 nan 0.0500 0.0010
20 0.0117 nan 0.0500 0.0005
40 0.0043 nan 0.0500 0.0001
60 0.0018 nan 0.0500 0.0001
80 0.0010 nan 0.0500 0.0000
100 0.0005 nan 0.0500 0.0000
120 0.0003 nan 0.0500 0.0000
140 0.0002 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold09: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold09: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0379 nan 0.0500 0.0025
2 0.0357 nan 0.0500 0.0019
3 0.0335 nan 0.0500 0.0017
4 0.0320 nan 0.0500 0.0015
5 0.0301 nan 0.0500 0.0021
6 0.0285 nan 0.0500 0.0017
7 0.0273 nan 0.0500 0.0002
8 0.0256 nan 0.0500 0.0002
9 0.0236 nan 0.0500 0.0011
10 0.0228 nan 0.0500 -0.0001
20 0.0141 nan 0.0500 0.0007
40 0.0075 nan 0.0500 0.0002
60 0.0045 nan 0.0500 0.0001
80 0.0030 nan 0.0500 -0.0000
100 0.0021 nan 0.0500 0.0000
120 0.0013 nan 0.0500 -0.0000
140 0.0009 nan 0.0500 0.0000
160 0.0007 nan 0.0500 0.0000
180 0.0005 nan 0.0500 0.0000
200 0.0004 nan 0.0500 0.0000
- Fold09: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold09: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0379 nan 0.0500 0.0026
2 0.0352 nan 0.0500 0.0002
3 0.0319 nan 0.0500 0.0030
4 0.0295 nan 0.0500 0.0015
5 0.0288 nan 0.0500 -0.0001
6 0.0261 nan 0.0500 0.0022
7 0.0239 nan 0.0500 0.0026
8 0.0215 nan 0.0500 0.0021
9 0.0200 nan 0.0500 0.0005
10 0.0193 nan 0.0500 -0.0001
20 0.0110 nan 0.0500 0.0003
40 0.0030 nan 0.0500 0.0003
60 0.0010 nan 0.0500 0.0000
80 0.0004 nan 0.0500 0.0000
100 0.0002 nan 0.0500 0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0000 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 0.0000
- Fold09: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold09: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0377 nan 0.0500 0.0024
2 0.0358 nan 0.0500 0.0004
3 0.0334 nan 0.0500 0.0019
4 0.0312 nan 0.0500 0.0004
5 0.0299 nan 0.0500 0.0003
6 0.0287 nan 0.0500 0.0002
7 0.0263 nan 0.0500 0.0018
8 0.0242 nan 0.0500 0.0018
9 0.0237 nan 0.0500 -0.0003
10 0.0221 nan 0.0500 0.0013
20 0.0121 nan 0.0500 0.0007
40 0.0044 nan 0.0500 -0.0000
60 0.0019 nan 0.0500 -0.0001
80 0.0009 nan 0.0500 0.0000
100 0.0005 nan 0.0500 0.0000
120 0.0003 nan 0.0500 -0.0000
140 0.0002 nan 0.0500 0.0000
160 0.0001 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold09: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold09: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0380 nan 0.0500 0.0028
2 0.0358 nan 0.0500 0.0022
3 0.0344 nan 0.0500 0.0010
4 0.0333 nan 0.0500 0.0011
5 0.0309 nan 0.0500 0.0018
6 0.0294 nan 0.0500 0.0006
7 0.0278 nan 0.0500 0.0010
8 0.0262 nan 0.0500 0.0017
9 0.0248 nan 0.0500 0.0013
10 0.0234 nan 0.0500 0.0008
20 0.0128 nan 0.0500 0.0000
40 0.0054 nan 0.0500 0.0001
60 0.0032 nan 0.0500 -0.0000
80 0.0020 nan 0.0500 0.0000
100 0.0013 nan 0.0500 0.0000
120 0.0009 nan 0.0500 -0.0000
140 0.0006 nan 0.0500 0.0000
160 0.0005 nan 0.0500 -0.0000
180 0.0004 nan 0.0500 -0.0000
200 0.0003 nan 0.0500 -0.0000
- Fold09: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold09: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0375 nan 0.1000 0.0027
2 0.0321 nan 0.1000 0.0041
3 0.0279 nan 0.1000 0.0012
4 0.0244 nan 0.1000 0.0023
5 0.0217 nan 0.1000 0.0022
6 0.0198 nan 0.1000 0.0010
7 0.0182 nan 0.1000 0.0016
8 0.0162 nan 0.1000 0.0014
9 0.0151 nan 0.1000 0.0010
10 0.0139 nan 0.1000 0.0009
20 0.0057 nan 0.1000 0.0002
40 0.0018 nan 0.1000 0.0000
60 0.0008 nan 0.1000 -0.0000
80 0.0004 nan 0.1000 -0.0000
100 0.0002 nan 0.1000 -0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold09: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold09: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0367 nan 0.1000 0.0036
2 0.0317 nan 0.1000 0.0045
3 0.0275 nan 0.1000 0.0036
4 0.0237 nan 0.1000 0.0020
5 0.0213 nan 0.1000 0.0024
6 0.0190 nan 0.1000 0.0015
7 0.0166 nan 0.1000 0.0019
8 0.0159 nan 0.1000 -0.0011
9 0.0146 nan 0.1000 0.0006
10 0.0135 nan 0.1000 0.0004
20 0.0064 nan 0.1000 0.0007
40 0.0020 nan 0.1000 0.0001
60 0.0007 nan 0.1000 0.0000
80 0.0003 nan 0.1000 0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 0.0000
- Fold09: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold09: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0364 nan 0.1000 0.0037
2 0.0333 nan 0.1000 0.0011
3 0.0311 nan 0.1000 0.0011
4 0.0282 nan 0.1000 0.0011
5 0.0257 nan 0.1000 0.0007
6 0.0225 nan 0.1000 0.0015
7 0.0198 nan 0.1000 0.0022
8 0.0180 nan 0.1000 0.0019
9 0.0169 nan 0.1000 0.0012
10 0.0148 nan 0.1000 0.0012
20 0.0074 nan 0.1000 0.0005
40 0.0030 nan 0.1000 -0.0000
60 0.0014 nan 0.1000 -0.0001
80 0.0007 nan 0.1000 -0.0000
100 0.0004 nan 0.1000 -0.0000
120 0.0002 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold09: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold09: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0387 nan 0.1000 -0.0016
2 0.0346 nan 0.1000 -0.0003
3 0.0294 nan 0.1000 0.0051
4 0.0260 nan 0.1000 0.0038
5 0.0233 nan 0.1000 0.0027
6 0.0198 nan 0.1000 0.0013
7 0.0175 nan 0.1000 0.0022
8 0.0162 nan 0.1000 0.0016
9 0.0131 nan 0.1000 0.0016
10 0.0116 nan 0.1000 -0.0001
20 0.0042 nan 0.1000 0.0003
40 0.0010 nan 0.1000 0.0000
60 0.0004 nan 0.1000 0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold09: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold09: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0350 nan 0.1000 0.0054
2 0.0302 nan 0.1000 0.0055
3 0.0266 nan 0.1000 0.0034
4 0.0227 nan 0.1000 0.0030
5 0.0194 nan 0.1000 0.0024
6 0.0171 nan 0.1000 0.0023
7 0.0151 nan 0.1000 -0.0002
8 0.0136 nan 0.1000 0.0014
9 0.0115 nan 0.1000 0.0018
10 0.0102 nan 0.1000 0.0009
20 0.0037 nan 0.1000 0.0003
40 0.0009 nan 0.1000 -0.0001
60 0.0003 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold09: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold09: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0359 nan 0.1000 0.0055
2 0.0319 nan 0.1000 0.0029
3 0.0273 nan 0.1000 0.0026
4 0.0257 nan 0.1000 0.0005
5 0.0251 nan 0.1000 -0.0001
6 0.0239 nan 0.1000 0.0004
7 0.0217 nan 0.1000 0.0017
8 0.0195 nan 0.1000 -0.0003
9 0.0181 nan 0.1000 0.0017
10 0.0161 nan 0.1000 0.0004
20 0.0080 nan 0.1000 0.0004
40 0.0034 nan 0.1000 -0.0000
60 0.0019 nan 0.1000 0.0001
80 0.0012 nan 0.1000 -0.0000
100 0.0007 nan 0.1000 0.0000
120 0.0005 nan 0.1000 -0.0000
140 0.0003 nan 0.1000 -0.0000
160 0.0002 nan 0.1000 0.0000
180 0.0001 nan 0.1000 0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold09: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold09: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0338 nan 0.1000 0.0049
2 0.0298 nan 0.1000 0.0007
3 0.0256 nan 0.1000 0.0035
4 0.0229 nan 0.1000 0.0008
5 0.0194 nan 0.1000 0.0038
6 0.0170 nan 0.1000 0.0025
7 0.0142 nan 0.1000 0.0022
8 0.0120 nan 0.1000 0.0014
9 0.0110 nan 0.1000 -0.0005
10 0.0097 nan 0.1000 0.0009
20 0.0035 nan 0.1000 0.0003
40 0.0005 nan 0.1000 -0.0000
60 0.0001 nan 0.1000 0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold09: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold09: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0350 nan 0.1000 0.0059
2 0.0307 nan 0.1000 0.0034
3 0.0274 nan 0.1000 0.0024
4 0.0252 nan 0.1000 0.0010
5 0.0217 nan 0.1000 0.0024
6 0.0197 nan 0.1000 0.0025
7 0.0186 nan 0.1000 0.0009
8 0.0167 nan 0.1000 0.0003
9 0.0152 nan 0.1000 0.0018
10 0.0136 nan 0.1000 0.0018
20 0.0038 nan 0.1000 0.0001
40 0.0016 nan 0.1000 -0.0001
60 0.0008 nan 0.1000 -0.0000
80 0.0004 nan 0.1000 -0.0000
100 0.0002 nan 0.1000 -0.0000
120 0.0001 nan 0.1000 0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 0.0000
- Fold09: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold09: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0340 nan 0.1000 0.0051
2 0.0305 nan 0.1000 0.0032
3 0.0271 nan 0.1000 0.0034
4 0.0243 nan 0.1000 0.0028
5 0.0217 nan 0.1000 0.0020
6 0.0194 nan 0.1000 0.0022
7 0.0176 nan 0.1000 0.0015
8 0.0157 nan 0.1000 0.0012
9 0.0142 nan 0.1000 0.0017
10 0.0136 nan 0.1000 0.0001
20 0.0067 nan 0.1000 -0.0004
40 0.0028 nan 0.1000 -0.0002
60 0.0012 nan 0.1000 -0.0000
80 0.0005 nan 0.1000 0.0000
100 0.0003 nan 0.1000 -0.0000
120 0.0002 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold09: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold10: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0436 nan 0.0100 0.0003
2 0.0432 nan 0.0100 0.0001
3 0.0426 nan 0.0100 0.0005
4 0.0421 nan 0.0100 0.0000
5 0.0418 nan 0.0100 0.0001
6 0.0413 nan 0.0100 0.0004
7 0.0408 nan 0.0100 0.0006
8 0.0402 nan 0.0100 0.0005
9 0.0397 nan 0.0100 0.0004
10 0.0391 nan 0.0100 0.0005
20 0.0349 nan 0.0100 0.0004
40 0.0276 nan 0.0100 0.0000
60 0.0224 nan 0.0100 0.0002
80 0.0177 nan 0.0100 0.0002
100 0.0145 nan 0.0100 0.0001
120 0.0123 nan 0.0100 0.0000
140 0.0105 nan 0.0100 -0.0000
160 0.0087 nan 0.0100 0.0000
180 0.0072 nan 0.0100 0.0000
200 0.0061 nan 0.0100 0.0001
- Fold10: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold10: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0434 nan 0.0100 0.0006
2 0.0429 nan 0.0100 0.0002
3 0.0424 nan 0.0100 0.0005
4 0.0420 nan 0.0100 0.0002
5 0.0414 nan 0.0100 0.0005
6 0.0413 nan 0.0100 -0.0002
7 0.0408 nan 0.0100 0.0004
8 0.0404 nan 0.0100 0.0004
9 0.0399 nan 0.0100 0.0005
10 0.0396 nan 0.0100 0.0002
20 0.0346 nan 0.0100 0.0004
40 0.0276 nan 0.0100 0.0004
60 0.0223 nan 0.0100 0.0002
80 0.0187 nan 0.0100 0.0001
100 0.0152 nan 0.0100 0.0001
120 0.0128 nan 0.0100 0.0001
140 0.0106 nan 0.0100 0.0000
160 0.0089 nan 0.0100 -0.0001
180 0.0075 nan 0.0100 0.0000
200 0.0063 nan 0.0100 0.0000
- Fold10: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold10: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0435 nan 0.0100 0.0001
2 0.0430 nan 0.0100 0.0005
3 0.0427 nan 0.0100 0.0002
4 0.0422 nan 0.0100 0.0004
5 0.0416 nan 0.0100 0.0003
6 0.0410 nan 0.0100 0.0005
7 0.0406 nan 0.0100 0.0003
8 0.0402 nan 0.0100 0.0005
9 0.0396 nan 0.0100 0.0004
10 0.0391 nan 0.0100 0.0005
20 0.0348 nan 0.0100 0.0005
40 0.0284 nan 0.0100 0.0001
60 0.0233 nan 0.0100 -0.0001
80 0.0191 nan 0.0100 0.0001
100 0.0161 nan 0.0100 0.0001
120 0.0138 nan 0.0100 0.0001
140 0.0120 nan 0.0100 0.0000
160 0.0104 nan 0.0100 0.0000
180 0.0091 nan 0.0100 0.0000
200 0.0081 nan 0.0100 0.0000
- Fold10: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold10: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0438 nan 0.0100 -0.0001
2 0.0431 nan 0.0100 0.0005
3 0.0424 nan 0.0100 0.0007
4 0.0421 nan 0.0100 0.0003
5 0.0414 nan 0.0100 0.0002
6 0.0406 nan 0.0100 0.0006
7 0.0402 nan 0.0100 0.0003
8 0.0394 nan 0.0100 0.0006
9 0.0389 nan 0.0100 0.0005
10 0.0384 nan 0.0100 0.0002
20 0.0339 nan 0.0100 0.0001
40 0.0252 nan 0.0100 0.0001
60 0.0198 nan 0.0100 0.0000
80 0.0152 nan 0.0100 0.0000
100 0.0118 nan 0.0100 0.0001
120 0.0092 nan 0.0100 0.0001
140 0.0075 nan 0.0100 0.0000
160 0.0059 nan 0.0100 0.0001
180 0.0047 nan 0.0100 0.0000
200 0.0038 nan 0.0100 0.0000
- Fold10: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold10: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0434 nan 0.0100 0.0006
2 0.0427 nan 0.0100 0.0006
3 0.0423 nan 0.0100 0.0004
4 0.0417 nan 0.0100 0.0004
5 0.0416 nan 0.0100 -0.0003
6 0.0410 nan 0.0100 0.0004
7 0.0405 nan 0.0100 0.0005
8 0.0400 nan 0.0100 0.0005
9 0.0393 nan 0.0100 0.0007
10 0.0387 nan 0.0100 0.0005
20 0.0342 nan 0.0100 0.0004
40 0.0262 nan 0.0100 -0.0000
60 0.0200 nan 0.0100 0.0002
80 0.0154 nan 0.0100 0.0002
100 0.0124 nan 0.0100 -0.0000
120 0.0097 nan 0.0100 0.0001
140 0.0079 nan 0.0100 0.0001
160 0.0063 nan 0.0100 0.0001
180 0.0051 nan 0.0100 -0.0000
200 0.0040 nan 0.0100 0.0000
- Fold10: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold10: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0435 nan 0.0100 0.0004
2 0.0432 nan 0.0100 0.0001
3 0.0427 nan 0.0100 0.0006
4 0.0421 nan 0.0100 0.0006
5 0.0416 nan 0.0100 0.0005
6 0.0410 nan 0.0100 0.0005
7 0.0406 nan 0.0100 0.0003
8 0.0401 nan 0.0100 0.0005
9 0.0396 nan 0.0100 0.0004
10 0.0392 nan 0.0100 0.0004
20 0.0349 nan 0.0100 0.0004
40 0.0282 nan 0.0100 0.0003
60 0.0229 nan 0.0100 -0.0001
80 0.0189 nan 0.0100 0.0002
100 0.0162 nan 0.0100 0.0001
120 0.0138 nan 0.0100 0.0001
140 0.0120 nan 0.0100 0.0001
160 0.0105 nan 0.0100 0.0001
180 0.0094 nan 0.0100 -0.0000
200 0.0085 nan 0.0100 0.0000
- Fold10: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold10: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0432 nan 0.0100 0.0006
2 0.0428 nan 0.0100 0.0003
3 0.0421 nan 0.0100 0.0008
4 0.0415 nan 0.0100 0.0004
5 0.0409 nan 0.0100 0.0005
6 0.0405 nan 0.0100 0.0003
7 0.0398 nan 0.0100 0.0005
8 0.0392 nan 0.0100 0.0005
9 0.0387 nan 0.0100 0.0003
10 0.0381 nan 0.0100 0.0001
20 0.0335 nan 0.0100 0.0001
40 0.0249 nan 0.0100 0.0004
60 0.0190 nan 0.0100 0.0001
80 0.0146 nan 0.0100 0.0001
100 0.0114 nan 0.0100 0.0001
120 0.0089 nan 0.0100 0.0001
140 0.0070 nan 0.0100 0.0001
160 0.0054 nan 0.0100 0.0001
180 0.0043 nan 0.0100 0.0000
200 0.0034 nan 0.0100 0.0000
- Fold10: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold10: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0433 nan 0.0100 0.0006
2 0.0426 nan 0.0100 0.0006
3 0.0420 nan 0.0100 0.0003
4 0.0414 nan 0.0100 0.0005
5 0.0409 nan 0.0100 0.0005
6 0.0401 nan 0.0100 0.0008
7 0.0396 nan 0.0100 0.0005
8 0.0390 nan 0.0100 0.0004
9 0.0384 nan 0.0100 0.0005
10 0.0380 nan 0.0100 0.0003
20 0.0328 nan 0.0100 0.0004
40 0.0256 nan 0.0100 0.0002
60 0.0201 nan 0.0100 -0.0000
80 0.0157 nan 0.0100 0.0001
100 0.0121 nan 0.0100 0.0000
120 0.0095 nan 0.0100 0.0001
140 0.0077 nan 0.0100 0.0001
160 0.0063 nan 0.0100 0.0000
180 0.0050 nan 0.0100 0.0000
200 0.0041 nan 0.0100 0.0000
- Fold10: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold10: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0433 nan 0.0100 0.0005
2 0.0427 nan 0.0100 0.0006
3 0.0422 nan 0.0100 0.0005
4 0.0417 nan 0.0100 0.0005
5 0.0412 nan 0.0100 0.0004
6 0.0405 nan 0.0100 0.0006
7 0.0401 nan 0.0100 0.0005
8 0.0395 nan 0.0100 0.0005
9 0.0391 nan 0.0100 0.0002
10 0.0388 nan 0.0100 0.0002
20 0.0348 nan 0.0100 -0.0000
40 0.0278 nan 0.0100 0.0000
60 0.0230 nan 0.0100 0.0002
80 0.0195 nan 0.0100 -0.0000
100 0.0163 nan 0.0100 0.0002
120 0.0137 nan 0.0100 0.0001
140 0.0118 nan 0.0100 0.0001
160 0.0102 nan 0.0100 0.0001
180 0.0089 nan 0.0100 0.0000
200 0.0078 nan 0.0100 0.0000
- Fold10: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold10: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0410 nan 0.0500 0.0018
2 0.0402 nan 0.0500 -0.0004
3 0.0379 nan 0.0500 0.0024
4 0.0346 nan 0.0500 0.0020
5 0.0322 nan 0.0500 0.0020
6 0.0299 nan 0.0500 0.0023
7 0.0281 nan 0.0500 0.0016
8 0.0264 nan 0.0500 0.0020
9 0.0247 nan 0.0500 0.0012
10 0.0232 nan 0.0500 0.0008
20 0.0143 nan 0.0500 0.0004
40 0.0063 nan 0.0500 0.0003
60 0.0029 nan 0.0500 0.0001
80 0.0016 nan 0.0500 0.0000
100 0.0010 nan 0.0500 -0.0000
120 0.0006 nan 0.0500 -0.0000
140 0.0004 nan 0.0500 -0.0000
160 0.0003 nan 0.0500 0.0000
180 0.0002 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold10: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold10: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0424 nan 0.0500 0.0016
2 0.0414 nan 0.0500 -0.0014
3 0.0383 nan 0.0500 0.0028
4 0.0369 nan 0.0500 0.0010
5 0.0359 nan 0.0500 -0.0001
6 0.0335 nan 0.0500 0.0023
7 0.0317 nan 0.0500 0.0021
8 0.0295 nan 0.0500 0.0012
9 0.0282 nan 0.0500 0.0017
10 0.0269 nan 0.0500 0.0014
20 0.0174 nan 0.0500 0.0000
40 0.0070 nan 0.0500 0.0001
60 0.0040 nan 0.0500 0.0001
80 0.0021 nan 0.0500 0.0000
100 0.0012 nan 0.0500 0.0000
120 0.0007 nan 0.0500 0.0000
140 0.0005 nan 0.0500 0.0000
160 0.0003 nan 0.0500 -0.0000
180 0.0002 nan 0.0500 0.0000
200 0.0001 nan 0.0500 0.0000
- Fold10: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold10: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0414 nan 0.0500 0.0028
2 0.0393 nan 0.0500 0.0018
3 0.0374 nan 0.0500 0.0013
4 0.0352 nan 0.0500 0.0006
5 0.0335 nan 0.0500 0.0003
6 0.0320 nan 0.0500 0.0013
7 0.0303 nan 0.0500 0.0014
8 0.0286 nan 0.0500 0.0016
9 0.0267 nan 0.0500 0.0016
10 0.0253 nan 0.0500 0.0015
20 0.0151 nan 0.0500 0.0005
40 0.0070 nan 0.0500 -0.0000
60 0.0041 nan 0.0500 0.0000
80 0.0026 nan 0.0500 -0.0000
100 0.0017 nan 0.0500 -0.0000
120 0.0011 nan 0.0500 -0.0000
140 0.0008 nan 0.0500 -0.0000
160 0.0006 nan 0.0500 -0.0000
180 0.0004 nan 0.0500 -0.0000
200 0.0003 nan 0.0500 0.0000
- Fold10: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold10: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0411 nan 0.0500 0.0023
2 0.0382 nan 0.0500 0.0027
3 0.0359 nan 0.0500 0.0018
4 0.0337 nan 0.0500 0.0021
5 0.0305 nan 0.0500 0.0030
6 0.0286 nan 0.0500 0.0022
7 0.0266 nan 0.0500 0.0013
8 0.0246 nan 0.0500 0.0016
9 0.0236 nan 0.0500 0.0008
10 0.0229 nan 0.0500 0.0002
20 0.0123 nan 0.0500 0.0007
40 0.0038 nan 0.0500 0.0001
60 0.0014 nan 0.0500 0.0000
80 0.0006 nan 0.0500 -0.0000
100 0.0003 nan 0.0500 -0.0000
120 0.0001 nan 0.0500 0.0000
140 0.0001 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold10: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold10: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0410 nan 0.0500 0.0021
2 0.0376 nan 0.0500 0.0023
3 0.0350 nan 0.0500 0.0012
4 0.0329 nan 0.0500 0.0018
5 0.0308 nan 0.0500 0.0022
6 0.0291 nan 0.0500 0.0014
7 0.0275 nan 0.0500 0.0000
8 0.0261 nan 0.0500 0.0010
9 0.0249 nan 0.0500 0.0010
10 0.0238 nan 0.0500 0.0008
20 0.0129 nan 0.0500 0.0001
40 0.0050 nan 0.0500 0.0001
60 0.0024 nan 0.0500 0.0000
80 0.0014 nan 0.0500 0.0000
100 0.0008 nan 0.0500 -0.0000
120 0.0005 nan 0.0500 -0.0000
140 0.0003 nan 0.0500 0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold10: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold10: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0419 nan 0.0500 0.0022
2 0.0391 nan 0.0500 0.0024
3 0.0378 nan 0.0500 0.0003
4 0.0351 nan 0.0500 0.0012
5 0.0323 nan 0.0500 0.0023
6 0.0299 nan 0.0500 0.0015
7 0.0282 nan 0.0500 0.0015
8 0.0262 nan 0.0500 0.0013
9 0.0256 nan 0.0500 0.0001
10 0.0245 nan 0.0500 0.0009
20 0.0144 nan 0.0500 0.0004
40 0.0073 nan 0.0500 0.0000
60 0.0044 nan 0.0500 -0.0000
80 0.0030 nan 0.0500 -0.0001
100 0.0020 nan 0.0500 -0.0000
120 0.0015 nan 0.0500 -0.0000
140 0.0010 nan 0.0500 -0.0000
160 0.0008 nan 0.0500 -0.0000
180 0.0005 nan 0.0500 -0.0000
200 0.0004 nan 0.0500 -0.0000
- Fold10: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold10: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0402 nan 0.0500 0.0016
2 0.0368 nan 0.0500 0.0029
3 0.0351 nan 0.0500 0.0001
4 0.0329 nan 0.0500 0.0014
5 0.0314 nan 0.0500 0.0012
6 0.0295 nan 0.0500 0.0003
7 0.0271 nan 0.0500 0.0020
8 0.0254 nan 0.0500 0.0007
9 0.0234 nan 0.0500 0.0012
10 0.0218 nan 0.0500 0.0012
20 0.0124 nan 0.0500 -0.0006
40 0.0035 nan 0.0500 0.0000
60 0.0013 nan 0.0500 0.0000
80 0.0005 nan 0.0500 0.0000
100 0.0002 nan 0.0500 -0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0000 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 0.0000
- Fold10: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold10: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0408 nan 0.0500 0.0017
2 0.0378 nan 0.0500 0.0017
3 0.0351 nan 0.0500 0.0022
4 0.0322 nan 0.0500 0.0019
5 0.0295 nan 0.0500 0.0020
6 0.0275 nan 0.0500 0.0019
7 0.0256 nan 0.0500 0.0020
8 0.0249 nan 0.0500 -0.0001
9 0.0230 nan 0.0500 0.0012
10 0.0209 nan 0.0500 0.0014
20 0.0127 nan 0.0500 0.0005
40 0.0043 nan 0.0500 0.0001
60 0.0019 nan 0.0500 0.0001
80 0.0010 nan 0.0500 -0.0000
100 0.0005 nan 0.0500 -0.0000
120 0.0003 nan 0.0500 0.0000
140 0.0002 nan 0.0500 0.0000
160 0.0001 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold10: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold10: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0413 nan 0.0500 0.0026
2 0.0384 nan 0.0500 0.0010
3 0.0364 nan 0.0500 0.0019
4 0.0348 nan 0.0500 0.0016
5 0.0329 nan 0.0500 0.0022
6 0.0309 nan 0.0500 0.0018
7 0.0294 nan 0.0500 0.0015
8 0.0277 nan 0.0500 0.0017
9 0.0259 nan 0.0500 0.0017
10 0.0243 nan 0.0500 0.0004
20 0.0160 nan 0.0500 0.0005
40 0.0080 nan 0.0500 0.0000
60 0.0046 nan 0.0500 -0.0000
80 0.0028 nan 0.0500 -0.0000
100 0.0020 nan 0.0500 0.0001
120 0.0014 nan 0.0500 -0.0000
140 0.0010 nan 0.0500 -0.0000
160 0.0007 nan 0.0500 -0.0000
180 0.0006 nan 0.0500 0.0000
200 0.0004 nan 0.0500 -0.0000
- Fold10: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold10: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0407 nan 0.1000 0.0030
2 0.0361 nan 0.1000 0.0044
3 0.0304 nan 0.1000 0.0031
4 0.0271 nan 0.1000 0.0028
5 0.0239 nan 0.1000 0.0026
6 0.0214 nan 0.1000 0.0009
7 0.0193 nan 0.1000 0.0022
8 0.0165 nan 0.1000 0.0022
9 0.0151 nan 0.1000 0.0006
10 0.0134 nan 0.1000 0.0014
20 0.0065 nan 0.1000 0.0000
40 0.0019 nan 0.1000 -0.0000
60 0.0008 nan 0.1000 -0.0000
80 0.0003 nan 0.1000 0.0000
100 0.0002 nan 0.1000 -0.0000
120 0.0001 nan 0.1000 0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold10: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold10: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0369 nan 0.1000 0.0036
2 0.0359 nan 0.1000 -0.0027
3 0.0312 nan 0.1000 0.0045
4 0.0278 nan 0.1000 0.0034
5 0.0258 nan 0.1000 0.0010
6 0.0226 nan 0.1000 0.0029
7 0.0201 nan 0.1000 0.0015
8 0.0186 nan 0.1000 0.0004
9 0.0172 nan 0.1000 0.0013
10 0.0147 nan 0.1000 0.0012
20 0.0059 nan 0.1000 0.0003
40 0.0018 nan 0.1000 -0.0002
60 0.0006 nan 0.1000 -0.0001
80 0.0003 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold10: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold10: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0381 nan 0.1000 0.0048
2 0.0335 nan 0.1000 0.0027
3 0.0292 nan 0.1000 0.0043
4 0.0262 nan 0.1000 0.0032
5 0.0228 nan 0.1000 0.0027
6 0.0203 nan 0.1000 0.0023
7 0.0179 nan 0.1000 0.0012
8 0.0159 nan 0.1000 0.0013
9 0.0146 nan 0.1000 0.0013
10 0.0134 nan 0.1000 0.0005
20 0.0072 nan 0.1000 -0.0002
40 0.0027 nan 0.1000 0.0002
60 0.0014 nan 0.1000 -0.0001
80 0.0007 nan 0.1000 -0.0000
100 0.0003 nan 0.1000 -0.0000
120 0.0002 nan 0.1000 0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold10: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold10: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0397 nan 0.1000 0.0047
2 0.0351 nan 0.1000 0.0051
3 0.0288 nan 0.1000 0.0061
4 0.0250 nan 0.1000 0.0030
5 0.0212 nan 0.1000 0.0036
6 0.0190 nan 0.1000 -0.0005
7 0.0160 nan 0.1000 0.0024
8 0.0135 nan 0.1000 0.0022
9 0.0117 nan 0.1000 0.0011
10 0.0101 nan 0.1000 0.0008
20 0.0038 nan 0.1000 0.0002
40 0.0005 nan 0.1000 0.0000
60 0.0001 nan 0.1000 0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold10: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold10: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0371 nan 0.1000 0.0035
2 0.0331 nan 0.1000 0.0013
3 0.0280 nan 0.1000 0.0045
4 0.0251 nan 0.1000 0.0021
5 0.0226 nan 0.1000 0.0024
6 0.0202 nan 0.1000 0.0005
7 0.0165 nan 0.1000 0.0033
8 0.0147 nan 0.1000 0.0014
9 0.0133 nan 0.1000 0.0007
10 0.0122 nan 0.1000 -0.0001
20 0.0045 nan 0.1000 0.0000
40 0.0010 nan 0.1000 -0.0000
60 0.0003 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 0.0000
100 0.0000 nan 0.1000 0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 0.0000
- Fold10: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold10: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0393 nan 0.1000 0.0020
2 0.0346 nan 0.1000 0.0032
3 0.0333 nan 0.1000 0.0010
4 0.0307 nan 0.1000 0.0012
5 0.0278 nan 0.1000 0.0004
6 0.0247 nan 0.1000 0.0025
7 0.0213 nan 0.1000 0.0025
8 0.0206 nan 0.1000 0.0005
9 0.0184 nan 0.1000 0.0019
10 0.0171 nan 0.1000 0.0010
20 0.0090 nan 0.1000 0.0001
40 0.0029 nan 0.1000 0.0000
60 0.0013 nan 0.1000 0.0000
80 0.0006 nan 0.1000 0.0000
100 0.0003 nan 0.1000 -0.0000
120 0.0002 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 0.0000
- Fold10: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold10: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0381 nan 0.1000 0.0048
2 0.0331 nan 0.1000 0.0041
3 0.0274 nan 0.1000 0.0038
4 0.0228 nan 0.1000 0.0026
5 0.0195 nan 0.1000 0.0022
6 0.0166 nan 0.1000 0.0020
7 0.0147 nan 0.1000 0.0002
8 0.0123 nan 0.1000 0.0018
9 0.0108 nan 0.1000 -0.0000
10 0.0094 nan 0.1000 0.0003
20 0.0024 nan 0.1000 0.0002
40 0.0004 nan 0.1000 -0.0000
60 0.0001 nan 0.1000 -0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold10: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold10: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0400 nan 0.1000 0.0025
2 0.0353 nan 0.1000 0.0045
3 0.0294 nan 0.1000 0.0056
4 0.0255 nan 0.1000 0.0033
5 0.0229 nan 0.1000 0.0034
6 0.0205 nan 0.1000 0.0020
7 0.0184 nan 0.1000 0.0012
8 0.0162 nan 0.1000 0.0023
9 0.0147 nan 0.1000 0.0018
10 0.0134 nan 0.1000 0.0010
20 0.0044 nan 0.1000 0.0004
40 0.0007 nan 0.1000 -0.0000
60 0.0002 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold10: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold10: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0380 nan 0.1000 0.0048
2 0.0350 nan 0.1000 0.0025
3 0.0304 nan 0.1000 0.0017
4 0.0265 nan 0.1000 0.0031
5 0.0231 nan 0.1000 0.0030
6 0.0223 nan 0.1000 -0.0005
7 0.0205 nan 0.1000 0.0013
8 0.0194 nan 0.1000 0.0002
9 0.0172 nan 0.1000 0.0017
10 0.0163 nan 0.1000 0.0009
20 0.0092 nan 0.1000 0.0004
40 0.0031 nan 0.1000 -0.0001
60 0.0018 nan 0.1000 -0.0000
80 0.0009 nan 0.1000 0.0000
100 0.0005 nan 0.1000 -0.0000
120 0.0003 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold10: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold11: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0424 nan 0.0100 0.0005
2 0.0419 nan 0.0100 0.0004
3 0.0413 nan 0.0100 0.0005
4 0.0410 nan 0.0100 0.0000
5 0.0404 nan 0.0100 0.0005
6 0.0400 nan 0.0100 0.0001
7 0.0396 nan 0.0100 0.0003
8 0.0392 nan 0.0100 0.0003
9 0.0389 nan 0.0100 0.0003
10 0.0384 nan 0.0100 0.0005
20 0.0339 nan 0.0100 0.0003
40 0.0273 nan 0.0100 0.0002
60 0.0223 nan 0.0100 0.0002
80 0.0185 nan 0.0100 -0.0000
100 0.0153 nan 0.0100 0.0002
120 0.0126 nan 0.0100 -0.0000
140 0.0106 nan 0.0100 0.0001
160 0.0090 nan 0.0100 -0.0000
180 0.0077 nan 0.0100 0.0000
200 0.0066 nan 0.0100 0.0000
- Fold11: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold11: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0425 nan 0.0100 0.0003
2 0.0421 nan 0.0100 0.0002
3 0.0418 nan 0.0100 0.0002
4 0.0413 nan 0.0100 0.0001
5 0.0408 nan 0.0100 0.0005
6 0.0402 nan 0.0100 0.0005
7 0.0396 nan 0.0100 0.0006
8 0.0391 nan 0.0100 0.0005
9 0.0386 nan 0.0100 0.0003
10 0.0381 nan 0.0100 0.0003
20 0.0343 nan 0.0100 0.0002
40 0.0265 nan 0.0100 0.0003
60 0.0214 nan 0.0100 0.0001
80 0.0173 nan 0.0100 0.0000
100 0.0144 nan 0.0100 0.0000
120 0.0119 nan 0.0100 0.0000
140 0.0100 nan 0.0100 0.0000
160 0.0083 nan 0.0100 0.0001
180 0.0070 nan 0.0100 0.0000
200 0.0060 nan 0.0100 -0.0000
- Fold11: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold11: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0426 nan 0.0100 0.0003
2 0.0421 nan 0.0100 0.0004
3 0.0415 nan 0.0100 0.0005
4 0.0411 nan 0.0100 0.0002
5 0.0407 nan 0.0100 0.0004
6 0.0403 nan 0.0100 0.0004
7 0.0398 nan 0.0100 0.0005
8 0.0393 nan 0.0100 0.0005
9 0.0388 nan 0.0100 0.0004
10 0.0384 nan 0.0100 0.0003
20 0.0340 nan 0.0100 0.0002
40 0.0277 nan 0.0100 0.0003
60 0.0224 nan 0.0100 0.0001
80 0.0187 nan 0.0100 0.0001
100 0.0154 nan 0.0100 0.0001
120 0.0133 nan 0.0100 0.0001
140 0.0116 nan 0.0100 0.0000
160 0.0102 nan 0.0100 0.0001
180 0.0090 nan 0.0100 0.0001
200 0.0081 nan 0.0100 0.0000
- Fold11: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold11: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0422 nan 0.0100 0.0006
2 0.0414 nan 0.0100 0.0008
3 0.0409 nan 0.0100 0.0005
4 0.0406 nan 0.0100 -0.0000
5 0.0403 nan 0.0100 0.0001
6 0.0394 nan 0.0100 0.0004
7 0.0390 nan 0.0100 0.0005
8 0.0382 nan 0.0100 0.0008
9 0.0374 nan 0.0100 0.0005
10 0.0371 nan 0.0100 -0.0000
20 0.0322 nan 0.0100 0.0006
40 0.0240 nan 0.0100 0.0002
60 0.0185 nan 0.0100 0.0001
80 0.0145 nan 0.0100 0.0001
100 0.0114 nan 0.0100 0.0002
120 0.0090 nan 0.0100 0.0000
140 0.0071 nan 0.0100 0.0000
160 0.0056 nan 0.0100 0.0000
180 0.0045 nan 0.0100 0.0000
200 0.0036 nan 0.0100 0.0000
- Fold11: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold11: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0424 nan 0.0100 0.0006
2 0.0417 nan 0.0100 0.0007
3 0.0411 nan 0.0100 0.0005
4 0.0405 nan 0.0100 0.0005
5 0.0399 nan 0.0100 0.0003
6 0.0394 nan 0.0100 0.0006
7 0.0388 nan 0.0100 0.0005
8 0.0383 nan 0.0100 0.0004
9 0.0377 nan 0.0100 0.0002
10 0.0371 nan 0.0100 0.0004
20 0.0326 nan 0.0100 0.0004
40 0.0255 nan 0.0100 0.0002
60 0.0200 nan 0.0100 0.0002
80 0.0159 nan 0.0100 0.0002
100 0.0129 nan 0.0100 0.0000
120 0.0106 nan 0.0100 0.0000
140 0.0085 nan 0.0100 -0.0000
160 0.0071 nan 0.0100 0.0001
180 0.0058 nan 0.0100 -0.0000
200 0.0048 nan 0.0100 0.0001
- Fold11: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold11: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0426 nan 0.0100 0.0004
2 0.0421 nan 0.0100 0.0003
3 0.0418 nan 0.0100 0.0001
4 0.0415 nan 0.0100 0.0001
5 0.0412 nan 0.0100 -0.0000
6 0.0405 nan 0.0100 0.0006
7 0.0403 nan 0.0100 0.0000
8 0.0396 nan 0.0100 0.0003
9 0.0393 nan 0.0100 -0.0000
10 0.0389 nan 0.0100 0.0002
20 0.0344 nan 0.0100 0.0004
40 0.0276 nan 0.0100 0.0002
60 0.0227 nan 0.0100 0.0001
80 0.0190 nan 0.0100 0.0002
100 0.0164 nan 0.0100 0.0001
120 0.0141 nan 0.0100 -0.0000
140 0.0120 nan 0.0100 0.0001
160 0.0103 nan 0.0100 0.0001
180 0.0092 nan 0.0100 0.0000
200 0.0082 nan 0.0100 -0.0000
- Fold11: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold11: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0426 nan 0.0100 0.0005
2 0.0419 nan 0.0100 0.0003
3 0.0413 nan 0.0100 0.0003
4 0.0406 nan 0.0100 0.0009
5 0.0398 nan 0.0100 0.0005
6 0.0393 nan 0.0100 0.0002
7 0.0388 nan 0.0100 0.0004
8 0.0382 nan 0.0100 0.0005
9 0.0377 nan 0.0100 0.0002
10 0.0373 nan 0.0100 0.0004
20 0.0320 nan 0.0100 0.0005
40 0.0233 nan 0.0100 0.0002
60 0.0178 nan 0.0100 0.0002
80 0.0134 nan 0.0100 0.0001
100 0.0103 nan 0.0100 0.0000
120 0.0081 nan 0.0100 0.0000
140 0.0063 nan 0.0100 0.0000
160 0.0051 nan 0.0100 -0.0000
180 0.0041 nan 0.0100 0.0000
200 0.0032 nan 0.0100 0.0000
- Fold11: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold11: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0423 nan 0.0100 0.0005
2 0.0415 nan 0.0100 0.0006
3 0.0409 nan 0.0100 0.0006
4 0.0402 nan 0.0100 0.0007
5 0.0396 nan 0.0100 0.0004
6 0.0391 nan 0.0100 0.0004
7 0.0384 nan 0.0100 0.0002
8 0.0379 nan 0.0100 0.0004
9 0.0374 nan 0.0100 0.0002
10 0.0368 nan 0.0100 0.0005
20 0.0322 nan 0.0100 0.0003
40 0.0241 nan 0.0100 0.0003
60 0.0184 nan 0.0100 0.0002
80 0.0144 nan 0.0100 0.0002
100 0.0116 nan 0.0100 0.0001
120 0.0091 nan 0.0100 0.0001
140 0.0076 nan 0.0100 0.0001
160 0.0062 nan 0.0100 0.0001
180 0.0050 nan 0.0100 0.0000
200 0.0041 nan 0.0100 0.0000
- Fold11: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold11: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0425 nan 0.0100 0.0004
2 0.0421 nan 0.0100 0.0003
3 0.0416 nan 0.0100 0.0005
4 0.0410 nan 0.0100 0.0004
5 0.0407 nan 0.0100 0.0001
6 0.0401 nan 0.0100 0.0006
7 0.0397 nan 0.0100 0.0003
8 0.0394 nan 0.0100 0.0003
9 0.0390 nan 0.0100 0.0002
10 0.0386 nan 0.0100 0.0005
20 0.0342 nan 0.0100 0.0001
40 0.0278 nan 0.0100 0.0002
60 0.0225 nan 0.0100 0.0002
80 0.0188 nan 0.0100 0.0001
100 0.0157 nan 0.0100 0.0000
120 0.0134 nan 0.0100 0.0001
140 0.0115 nan 0.0100 0.0001
160 0.0101 nan 0.0100 0.0000
180 0.0088 nan 0.0100 0.0000
200 0.0079 nan 0.0100 0.0000
- Fold11: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold11: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0398 nan 0.0500 0.0028
2 0.0371 nan 0.0500 0.0026
3 0.0353 nan 0.0500 0.0001
4 0.0326 nan 0.0500 0.0022
5 0.0306 nan 0.0500 0.0013
6 0.0291 nan 0.0500 0.0014
7 0.0280 nan 0.0500 0.0001
8 0.0263 nan 0.0500 0.0011
9 0.0247 nan 0.0500 0.0017
10 0.0237 nan 0.0500 0.0007
20 0.0143 nan 0.0500 -0.0002
40 0.0062 nan 0.0500 0.0001
60 0.0031 nan 0.0500 -0.0001
80 0.0016 nan 0.0500 0.0000
100 0.0010 nan 0.0500 0.0000
120 0.0006 nan 0.0500 -0.0000
140 0.0003 nan 0.0500 0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 0.0000
- Fold11: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold11: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0404 nan 0.0500 0.0025
2 0.0383 nan 0.0500 0.0022
3 0.0362 nan 0.0500 0.0006
4 0.0354 nan 0.0500 0.0001
5 0.0345 nan 0.0500 0.0001
6 0.0330 nan 0.0500 0.0003
7 0.0309 nan 0.0500 0.0013
8 0.0301 nan 0.0500 0.0000
9 0.0286 nan 0.0500 0.0012
10 0.0270 nan 0.0500 0.0017
20 0.0158 nan 0.0500 0.0003
40 0.0069 nan 0.0500 0.0000
60 0.0033 nan 0.0500 0.0001
80 0.0018 nan 0.0500 0.0001
100 0.0012 nan 0.0500 0.0000
120 0.0008 nan 0.0500 0.0000
140 0.0005 nan 0.0500 -0.0000
160 0.0003 nan 0.0500 0.0000
180 0.0002 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 0.0000
- Fold11: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold11: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0397 nan 0.0500 0.0025
2 0.0379 nan 0.0500 0.0001
3 0.0350 nan 0.0500 0.0024
4 0.0331 nan 0.0500 0.0021
5 0.0312 nan 0.0500 0.0011
6 0.0293 nan 0.0500 0.0012
7 0.0273 nan 0.0500 0.0013
8 0.0257 nan 0.0500 0.0015
9 0.0238 nan 0.0500 0.0013
10 0.0224 nan 0.0500 0.0012
20 0.0146 nan 0.0500 0.0002
40 0.0072 nan 0.0500 -0.0001
60 0.0038 nan 0.0500 0.0001
80 0.0025 nan 0.0500 0.0000
100 0.0016 nan 0.0500 -0.0000
120 0.0011 nan 0.0500 0.0000
140 0.0008 nan 0.0500 -0.0000
160 0.0006 nan 0.0500 0.0000
180 0.0004 nan 0.0500 -0.0000
200 0.0003 nan 0.0500 0.0000
- Fold11: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold11: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0400 nan 0.0500 0.0021
2 0.0372 nan 0.0500 0.0015
3 0.0343 nan 0.0500 0.0015
4 0.0313 nan 0.0500 0.0024
5 0.0287 nan 0.0500 0.0012
6 0.0269 nan 0.0500 0.0011
7 0.0251 nan 0.0500 0.0012
8 0.0232 nan 0.0500 0.0013
9 0.0222 nan 0.0500 0.0002
10 0.0214 nan 0.0500 0.0000
20 0.0114 nan 0.0500 0.0007
40 0.0042 nan 0.0500 0.0001
60 0.0015 nan 0.0500 -0.0000
80 0.0008 nan 0.0500 -0.0000
100 0.0003 nan 0.0500 0.0000
120 0.0002 nan 0.0500 -0.0000
140 0.0001 nan 0.0500 0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold11: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold11: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0402 nan 0.0500 0.0013
2 0.0372 nan 0.0500 0.0024
3 0.0345 nan 0.0500 0.0028
4 0.0319 nan 0.0500 0.0025
5 0.0305 nan 0.0500 -0.0002
6 0.0292 nan 0.0500 0.0005
7 0.0268 nan 0.0500 0.0010
8 0.0250 nan 0.0500 0.0012
9 0.0226 nan 0.0500 0.0015
10 0.0206 nan 0.0500 0.0014
20 0.0111 nan 0.0500 0.0000
40 0.0040 nan 0.0500 0.0001
60 0.0017 nan 0.0500 -0.0000
80 0.0008 nan 0.0500 0.0000
100 0.0005 nan 0.0500 -0.0000
120 0.0003 nan 0.0500 0.0000
140 0.0002 nan 0.0500 -0.0000
160 0.0001 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold11: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold11: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0405 nan 0.0500 0.0020
2 0.0378 nan 0.0500 0.0023
3 0.0352 nan 0.0500 0.0022
4 0.0330 nan 0.0500 0.0020
5 0.0308 nan 0.0500 0.0019
6 0.0292 nan 0.0500 0.0013
7 0.0271 nan 0.0500 0.0017
8 0.0254 nan 0.0500 0.0004
9 0.0237 nan 0.0500 0.0010
10 0.0229 nan 0.0500 -0.0008
20 0.0143 nan 0.0500 0.0001
40 0.0072 nan 0.0500 0.0001
60 0.0040 nan 0.0500 0.0001
80 0.0027 nan 0.0500 0.0000
100 0.0020 nan 0.0500 0.0000
120 0.0015 nan 0.0500 -0.0000
140 0.0011 nan 0.0500 -0.0000
160 0.0008 nan 0.0500 0.0000
180 0.0006 nan 0.0500 -0.0000
200 0.0005 nan 0.0500 -0.0000
- Fold11: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold11: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0396 nan 0.0500 0.0033
2 0.0367 nan 0.0500 0.0020
3 0.0330 nan 0.0500 0.0022
4 0.0299 nan 0.0500 0.0023
5 0.0278 nan 0.0500 0.0022
6 0.0255 nan 0.0500 0.0021
7 0.0239 nan 0.0500 0.0014
8 0.0217 nan 0.0500 0.0025
9 0.0201 nan 0.0500 0.0014
10 0.0185 nan 0.0500 0.0010
20 0.0098 nan 0.0500 0.0003
40 0.0029 nan 0.0500 -0.0000
60 0.0013 nan 0.0500 0.0001
80 0.0005 nan 0.0500 -0.0000
100 0.0002 nan 0.0500 -0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0001 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold11: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold11: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0404 nan 0.0500 0.0024
2 0.0370 nan 0.0500 0.0029
3 0.0343 nan 0.0500 0.0021
4 0.0320 nan 0.0500 0.0022
5 0.0300 nan 0.0500 0.0016
6 0.0281 nan 0.0500 0.0020
7 0.0268 nan 0.0500 -0.0002
8 0.0245 nan 0.0500 0.0014
9 0.0230 nan 0.0500 0.0005
10 0.0218 nan 0.0500 0.0005
20 0.0129 nan 0.0500 -0.0004
40 0.0045 nan 0.0500 0.0001
60 0.0021 nan 0.0500 0.0000
80 0.0009 nan 0.0500 0.0000
100 0.0006 nan 0.0500 -0.0000
120 0.0004 nan 0.0500 -0.0000
140 0.0003 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold11: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold11: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0405 nan 0.0500 0.0026
2 0.0392 nan 0.0500 0.0005
3 0.0373 nan 0.0500 0.0024
4 0.0351 nan 0.0500 0.0016
5 0.0328 nan 0.0500 0.0012
6 0.0304 nan 0.0500 0.0021
7 0.0289 nan 0.0500 0.0017
8 0.0271 nan 0.0500 0.0014
9 0.0264 nan 0.0500 0.0004
10 0.0249 nan 0.0500 0.0014
20 0.0161 nan 0.0500 0.0008
40 0.0085 nan 0.0500 0.0001
60 0.0048 nan 0.0500 -0.0001
80 0.0030 nan 0.0500 -0.0000
100 0.0019 nan 0.0500 -0.0000
120 0.0014 nan 0.0500 -0.0000
140 0.0010 nan 0.0500 0.0000
160 0.0007 nan 0.0500 -0.0000
180 0.0005 nan 0.0500 -0.0000
200 0.0004 nan 0.0500 -0.0000
- Fold11: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold11: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0364 nan 0.1000 0.0054
2 0.0315 nan 0.1000 0.0034
3 0.0266 nan 0.1000 0.0023
4 0.0255 nan 0.1000 -0.0011
5 0.0247 nan 0.1000 -0.0017
6 0.0217 nan 0.1000 0.0023
7 0.0191 nan 0.1000 0.0012
8 0.0171 nan 0.1000 0.0012
9 0.0148 nan 0.1000 0.0019
10 0.0137 nan 0.1000 0.0000
20 0.0055 nan 0.1000 -0.0000
40 0.0014 nan 0.1000 -0.0001
60 0.0005 nan 0.1000 0.0000
80 0.0002 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold11: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold11: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0397 nan 0.1000 0.0020
2 0.0345 nan 0.1000 0.0040
3 0.0304 nan 0.1000 0.0039
4 0.0280 nan 0.1000 0.0005
5 0.0246 nan 0.1000 0.0033
6 0.0223 nan 0.1000 0.0012
7 0.0205 nan 0.1000 0.0007
8 0.0183 nan 0.1000 0.0012
9 0.0169 nan 0.1000 0.0018
10 0.0147 nan 0.1000 0.0011
20 0.0064 nan 0.1000 -0.0000
40 0.0023 nan 0.1000 -0.0002
60 0.0009 nan 0.1000 -0.0000
80 0.0005 nan 0.1000 -0.0000
100 0.0002 nan 0.1000 0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold11: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold11: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0380 nan 0.1000 0.0050
2 0.0333 nan 0.1000 0.0019
3 0.0303 nan 0.1000 0.0015
4 0.0276 nan 0.1000 0.0032
5 0.0246 nan 0.1000 0.0030
6 0.0219 nan 0.1000 0.0025
7 0.0195 nan 0.1000 0.0019
8 0.0182 nan 0.1000 0.0007
9 0.0167 nan 0.1000 0.0015
10 0.0160 nan 0.1000 0.0002
20 0.0079 nan 0.1000 0.0005
40 0.0032 nan 0.1000 -0.0001
60 0.0015 nan 0.1000 -0.0001
80 0.0010 nan 0.1000 -0.0001
100 0.0005 nan 0.1000 -0.0000
120 0.0004 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold11: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold11: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0367 nan 0.1000 0.0028
2 0.0305 nan 0.1000 0.0058
3 0.0274 nan 0.1000 0.0029
4 0.0233 nan 0.1000 0.0018
5 0.0212 nan 0.1000 0.0015
6 0.0190 nan 0.1000 0.0017
7 0.0167 nan 0.1000 0.0022
8 0.0144 nan 0.1000 0.0026
9 0.0128 nan 0.1000 0.0000
10 0.0110 nan 0.1000 0.0011
20 0.0032 nan 0.1000 0.0003
40 0.0004 nan 0.1000 0.0000
60 0.0001 nan 0.1000 -0.0000
80 0.0000 nan 0.1000 0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 0.0000
160 0.0000 nan 0.1000 0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold11: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold11: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0377 nan 0.1000 0.0062
2 0.0330 nan 0.1000 0.0042
3 0.0297 nan 0.1000 0.0029
4 0.0275 nan 0.1000 0.0007
5 0.0243 nan 0.1000 0.0005
6 0.0214 nan 0.1000 0.0029
7 0.0182 nan 0.1000 0.0014
8 0.0160 nan 0.1000 0.0014
9 0.0146 nan 0.1000 0.0010
10 0.0131 nan 0.1000 0.0011
20 0.0039 nan 0.1000 -0.0000
40 0.0009 nan 0.1000 0.0001
60 0.0003 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold11: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold11: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0381 nan 0.1000 0.0047
2 0.0365 nan 0.1000 -0.0012
3 0.0332 nan 0.1000 0.0034
4 0.0289 nan 0.1000 0.0039
5 0.0249 nan 0.1000 0.0036
6 0.0235 nan 0.1000 0.0015
7 0.0205 nan 0.1000 0.0006
8 0.0184 nan 0.1000 0.0019
9 0.0164 nan 0.1000 0.0018
10 0.0147 nan 0.1000 0.0015
20 0.0072 nan 0.1000 0.0003
40 0.0027 nan 0.1000 0.0001
60 0.0011 nan 0.1000 0.0000
80 0.0006 nan 0.1000 -0.0000
100 0.0003 nan 0.1000 -0.0000
120 0.0002 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold11: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold11: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0383 nan 0.1000 0.0019
2 0.0337 nan 0.1000 0.0005
3 0.0300 nan 0.1000 0.0019
4 0.0287 nan 0.1000 -0.0007
5 0.0247 nan 0.1000 0.0013
6 0.0207 nan 0.1000 0.0031
7 0.0183 nan 0.1000 0.0025
8 0.0152 nan 0.1000 0.0027
9 0.0139 nan 0.1000 -0.0005
10 0.0125 nan 0.1000 0.0003
20 0.0045 nan 0.1000 0.0004
40 0.0006 nan 0.1000 -0.0001
60 0.0002 nan 0.1000 -0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold11: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold11: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0366 nan 0.1000 0.0058
2 0.0335 nan 0.1000 0.0015
3 0.0278 nan 0.1000 0.0042
4 0.0246 nan 0.1000 0.0026
5 0.0213 nan 0.1000 0.0024
6 0.0193 nan 0.1000 0.0010
7 0.0169 nan 0.1000 0.0015
8 0.0145 nan 0.1000 0.0004
9 0.0128 nan 0.1000 0.0017
10 0.0121 nan 0.1000 0.0003
20 0.0038 nan 0.1000 0.0001
40 0.0011 nan 0.1000 -0.0001
60 0.0002 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold11: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold11: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0369 nan 0.1000 0.0048
2 0.0335 nan 0.1000 0.0014
3 0.0301 nan 0.1000 0.0039
4 0.0267 nan 0.1000 0.0030
5 0.0236 nan 0.1000 0.0001
6 0.0218 nan 0.1000 0.0013
7 0.0202 nan 0.1000 -0.0004
8 0.0194 nan 0.1000 -0.0002
9 0.0175 nan 0.1000 0.0010
10 0.0157 nan 0.1000 0.0013
20 0.0088 nan 0.1000 0.0003
40 0.0041 nan 0.1000 0.0002
60 0.0019 nan 0.1000 0.0001
80 0.0009 nan 0.1000 -0.0000
100 0.0005 nan 0.1000 0.0000
120 0.0003 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold11: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold12: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0435 nan 0.0100 0.0005
2 0.0432 nan 0.0100 0.0001
3 0.0426 nan 0.0100 0.0005
4 0.0419 nan 0.0100 0.0005
5 0.0414 nan 0.0100 0.0006
6 0.0411 nan 0.0100 0.0001
7 0.0405 nan 0.0100 0.0005
8 0.0403 nan 0.0100 -0.0000
9 0.0400 nan 0.0100 -0.0000
10 0.0396 nan 0.0100 0.0001
20 0.0347 nan 0.0100 0.0004
40 0.0273 nan 0.0100 0.0003
60 0.0222 nan 0.0100 0.0002
80 0.0179 nan 0.0100 0.0002
100 0.0147 nan 0.0100 0.0001
120 0.0126 nan 0.0100 0.0000
140 0.0103 nan 0.0100 0.0000
160 0.0088 nan 0.0100 0.0000
180 0.0075 nan 0.0100 0.0000
200 0.0063 nan 0.0100 0.0000
- Fold12: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold12: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0436 nan 0.0100 0.0003
2 0.0430 nan 0.0100 0.0006
3 0.0425 nan 0.0100 0.0005
4 0.0418 nan 0.0100 0.0005
5 0.0415 nan 0.0100 0.0001
6 0.0410 nan 0.0100 0.0005
7 0.0403 nan 0.0100 0.0004
8 0.0397 nan 0.0100 0.0005
9 0.0394 nan 0.0100 0.0003
10 0.0388 nan 0.0100 0.0004
20 0.0343 nan 0.0100 0.0005
40 0.0275 nan 0.0100 0.0003
60 0.0218 nan 0.0100 0.0002
80 0.0179 nan 0.0100 0.0002
100 0.0146 nan 0.0100 -0.0000
120 0.0123 nan 0.0100 0.0001
140 0.0105 nan 0.0100 0.0000
160 0.0088 nan 0.0100 0.0000
180 0.0073 nan 0.0100 0.0001
200 0.0064 nan 0.0100 -0.0001
- Fold12: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold12: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0433 nan 0.0100 0.0005
2 0.0431 nan 0.0100 -0.0001
3 0.0426 nan 0.0100 0.0006
4 0.0421 nan 0.0100 0.0004
5 0.0415 nan 0.0100 0.0005
6 0.0412 nan 0.0100 0.0000
7 0.0408 nan 0.0100 0.0003
8 0.0404 nan 0.0100 0.0003
9 0.0399 nan 0.0100 0.0005
10 0.0393 nan 0.0100 0.0004
20 0.0349 nan 0.0100 0.0005
40 0.0283 nan 0.0100 0.0000
60 0.0234 nan 0.0100 0.0002
80 0.0191 nan 0.0100 0.0002
100 0.0160 nan 0.0100 0.0002
120 0.0136 nan 0.0100 -0.0000
140 0.0112 nan 0.0100 -0.0001
160 0.0099 nan 0.0100 0.0000
180 0.0086 nan 0.0100 -0.0000
200 0.0077 nan 0.0100 0.0000
- Fold12: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold12: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0433 nan 0.0100 0.0007
2 0.0430 nan 0.0100 0.0001
3 0.0427 nan 0.0100 -0.0001
4 0.0419 nan 0.0100 0.0008
5 0.0413 nan 0.0100 0.0000
6 0.0405 nan 0.0100 0.0006
7 0.0397 nan 0.0100 0.0007
8 0.0393 nan 0.0100 0.0005
9 0.0389 nan 0.0100 0.0002
10 0.0383 nan 0.0100 0.0005
20 0.0338 nan 0.0100 0.0003
40 0.0253 nan 0.0100 0.0002
60 0.0195 nan 0.0100 0.0002
80 0.0150 nan 0.0100 -0.0000
100 0.0117 nan 0.0100 0.0000
120 0.0091 nan 0.0100 -0.0000
140 0.0073 nan 0.0100 0.0000
160 0.0058 nan 0.0100 0.0000
180 0.0049 nan 0.0100 0.0000
200 0.0039 nan 0.0100 -0.0000
- Fold12: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold12: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0433 nan 0.0100 0.0006
2 0.0427 nan 0.0100 0.0004
3 0.0420 nan 0.0100 0.0005
4 0.0415 nan 0.0100 0.0002
5 0.0409 nan 0.0100 0.0004
6 0.0405 nan 0.0100 0.0005
7 0.0399 nan 0.0100 0.0007
8 0.0394 nan 0.0100 0.0004
9 0.0389 nan 0.0100 0.0004
10 0.0384 nan 0.0100 0.0004
20 0.0335 nan 0.0100 0.0003
40 0.0255 nan 0.0100 0.0003
60 0.0198 nan 0.0100 0.0001
80 0.0157 nan 0.0100 0.0000
100 0.0125 nan 0.0100 0.0001
120 0.0103 nan 0.0100 0.0000
140 0.0080 nan 0.0100 0.0001
160 0.0065 nan 0.0100 0.0001
180 0.0052 nan 0.0100 -0.0000
200 0.0044 nan 0.0100 0.0000
- Fold12: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold12: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0435 nan 0.0100 0.0005
2 0.0429 nan 0.0100 0.0006
3 0.0423 nan 0.0100 0.0005
4 0.0419 nan 0.0100 0.0006
5 0.0413 nan 0.0100 0.0005
6 0.0406 nan 0.0100 0.0005
7 0.0401 nan 0.0100 0.0005
8 0.0397 nan 0.0100 0.0002
9 0.0393 nan 0.0100 0.0002
10 0.0387 nan 0.0100 0.0004
20 0.0344 nan 0.0100 0.0002
40 0.0277 nan 0.0100 0.0003
60 0.0225 nan 0.0100 0.0001
80 0.0187 nan 0.0100 0.0001
100 0.0154 nan 0.0100 0.0001
120 0.0133 nan 0.0100 0.0001
140 0.0115 nan 0.0100 0.0001
160 0.0102 nan 0.0100 0.0001
180 0.0091 nan 0.0100 0.0001
200 0.0079 nan 0.0100 0.0000
- Fold12: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold12: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0435 nan 0.0100 0.0004
2 0.0430 nan 0.0100 0.0001
3 0.0424 nan 0.0100 0.0004
4 0.0419 nan 0.0100 0.0005
5 0.0415 nan 0.0100 0.0005
6 0.0409 nan 0.0100 0.0004
7 0.0402 nan 0.0100 0.0004
8 0.0396 nan 0.0100 0.0004
9 0.0389 nan 0.0100 0.0007
10 0.0384 nan 0.0100 0.0003
20 0.0333 nan 0.0100 0.0005
40 0.0249 nan 0.0100 0.0002
60 0.0181 nan 0.0100 0.0002
80 0.0137 nan 0.0100 0.0001
100 0.0104 nan 0.0100 0.0001
120 0.0079 nan 0.0100 0.0000
140 0.0062 nan 0.0100 -0.0000
160 0.0049 nan 0.0100 0.0000
180 0.0039 nan 0.0100 0.0000
200 0.0032 nan 0.0100 0.0000
- Fold12: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold12: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0434 nan 0.0100 0.0005
2 0.0426 nan 0.0100 0.0006
3 0.0421 nan 0.0100 0.0004
4 0.0413 nan 0.0100 0.0004
5 0.0408 nan 0.0100 0.0006
6 0.0401 nan 0.0100 0.0004
7 0.0395 nan 0.0100 0.0004
8 0.0389 nan 0.0100 0.0002
9 0.0383 nan 0.0100 0.0006
10 0.0379 nan 0.0100 0.0003
20 0.0324 nan 0.0100 0.0005
40 0.0244 nan 0.0100 0.0003
60 0.0189 nan 0.0100 0.0003
80 0.0143 nan 0.0100 0.0001
100 0.0112 nan 0.0100 0.0000
120 0.0088 nan 0.0100 0.0001
140 0.0071 nan 0.0100 0.0000
160 0.0057 nan 0.0100 0.0000
180 0.0046 nan 0.0100 0.0000
200 0.0039 nan 0.0100 -0.0000
- Fold12: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold12: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0433 nan 0.0100 0.0005
2 0.0429 nan 0.0100 0.0002
3 0.0424 nan 0.0100 0.0006
4 0.0416 nan 0.0100 0.0006
5 0.0413 nan 0.0100 0.0001
6 0.0409 nan 0.0100 0.0002
7 0.0404 nan 0.0100 0.0005
8 0.0400 nan 0.0100 0.0003
9 0.0396 nan 0.0100 0.0005
10 0.0391 nan 0.0100 0.0002
20 0.0349 nan 0.0100 0.0003
40 0.0281 nan 0.0100 0.0003
60 0.0230 nan 0.0100 -0.0001
80 0.0187 nan 0.0100 0.0001
100 0.0157 nan 0.0100 0.0001
120 0.0132 nan 0.0100 -0.0000
140 0.0114 nan 0.0100 -0.0000
160 0.0099 nan 0.0100 0.0000
180 0.0088 nan 0.0100 0.0001
200 0.0078 nan 0.0100 0.0000
- Fold12: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold12: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0430 nan 0.0500 -0.0009
2 0.0410 nan 0.0500 0.0017
3 0.0385 nan 0.0500 0.0028
4 0.0354 nan 0.0500 0.0021
5 0.0334 nan 0.0500 0.0014
6 0.0311 nan 0.0500 0.0020
7 0.0298 nan 0.0500 -0.0001
8 0.0286 nan 0.0500 0.0005
9 0.0265 nan 0.0500 0.0018
10 0.0248 nan 0.0500 0.0014
20 0.0136 nan 0.0500 0.0005
40 0.0055 nan 0.0500 -0.0000
60 0.0030 nan 0.0500 -0.0000
80 0.0016 nan 0.0500 0.0000
100 0.0010 nan 0.0500 -0.0000
120 0.0006 nan 0.0500 0.0000
140 0.0003 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 0.0000
180 0.0001 nan 0.0500 0.0000
200 0.0001 nan 0.0500 0.0000
- Fold12: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold12: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0417 nan 0.0500 0.0022
2 0.0392 nan 0.0500 0.0021
3 0.0368 nan 0.0500 0.0005
4 0.0350 nan 0.0500 0.0001
5 0.0333 nan 0.0500 0.0014
6 0.0309 nan 0.0500 0.0021
7 0.0290 nan 0.0500 0.0010
8 0.0272 nan 0.0500 0.0017
9 0.0261 nan 0.0500 0.0006
10 0.0244 nan 0.0500 0.0015
20 0.0144 nan 0.0500 -0.0004
40 0.0061 nan 0.0500 0.0002
60 0.0032 nan 0.0500 0.0000
80 0.0017 nan 0.0500 0.0001
100 0.0009 nan 0.0500 0.0000
120 0.0006 nan 0.0500 -0.0000
140 0.0003 nan 0.0500 0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold12: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold12: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0433 nan 0.0500 -0.0008
2 0.0407 nan 0.0500 0.0026
3 0.0387 nan 0.0500 0.0015
4 0.0367 nan 0.0500 0.0024
5 0.0341 nan 0.0500 0.0010
6 0.0319 nan 0.0500 0.0005
7 0.0303 nan 0.0500 0.0009
8 0.0286 nan 0.0500 0.0019
9 0.0267 nan 0.0500 0.0014
10 0.0259 nan 0.0500 0.0004
20 0.0156 nan 0.0500 0.0007
40 0.0080 nan 0.0500 0.0001
60 0.0049 nan 0.0500 0.0001
80 0.0034 nan 0.0500 -0.0001
100 0.0023 nan 0.0500 -0.0000
120 0.0017 nan 0.0500 -0.0001
140 0.0013 nan 0.0500 0.0000
160 0.0010 nan 0.0500 -0.0000
180 0.0008 nan 0.0500 0.0000
200 0.0006 nan 0.0500 0.0000
- Fold12: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold12: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0415 nan 0.0500 0.0021
2 0.0377 nan 0.0500 0.0028
3 0.0350 nan 0.0500 0.0018
4 0.0320 nan 0.0500 0.0024
5 0.0302 nan 0.0500 0.0012
6 0.0284 nan 0.0500 0.0017
7 0.0270 nan 0.0500 0.0012
8 0.0261 nan 0.0500 0.0002
9 0.0243 nan 0.0500 0.0008
10 0.0232 nan 0.0500 0.0006
20 0.0125 nan 0.0500 0.0006
40 0.0043 nan 0.0500 0.0003
60 0.0015 nan 0.0500 0.0000
80 0.0007 nan 0.0500 -0.0000
100 0.0003 nan 0.0500 0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0001 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold12: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold12: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0419 nan 0.0500 0.0015
2 0.0392 nan 0.0500 0.0019
3 0.0362 nan 0.0500 0.0021
4 0.0338 nan 0.0500 0.0017
5 0.0313 nan 0.0500 0.0019
6 0.0289 nan 0.0500 0.0015
7 0.0272 nan 0.0500 0.0016
8 0.0255 nan 0.0500 0.0011
9 0.0239 nan 0.0500 0.0014
10 0.0224 nan 0.0500 0.0013
20 0.0129 nan 0.0500 0.0010
40 0.0048 nan 0.0500 0.0003
60 0.0023 nan 0.0500 -0.0000
80 0.0012 nan 0.0500 -0.0000
100 0.0007 nan 0.0500 0.0000
120 0.0005 nan 0.0500 -0.0000
140 0.0003 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 0.0000
180 0.0001 nan 0.0500 0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold12: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold12: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0414 nan 0.0500 0.0027
2 0.0389 nan 0.0500 0.0025
3 0.0375 nan 0.0500 0.0000
4 0.0373 nan 0.0500 -0.0017
5 0.0347 nan 0.0500 0.0019
6 0.0328 nan 0.0500 0.0004
7 0.0308 nan 0.0500 0.0021
8 0.0290 nan 0.0500 0.0011
9 0.0276 nan 0.0500 0.0009
10 0.0262 nan 0.0500 0.0009
20 0.0179 nan 0.0500 0.0000
40 0.0083 nan 0.0500 0.0001
60 0.0043 nan 0.0500 0.0000
80 0.0025 nan 0.0500 0.0000
100 0.0018 nan 0.0500 -0.0000
120 0.0012 nan 0.0500 -0.0000
140 0.0008 nan 0.0500 0.0000
160 0.0006 nan 0.0500 -0.0000
180 0.0004 nan 0.0500 -0.0000
200 0.0003 nan 0.0500 -0.0000
- Fold12: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold12: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0398 nan 0.0500 0.0036
2 0.0372 nan 0.0500 0.0013
3 0.0340 nan 0.0500 0.0030
4 0.0323 nan 0.0500 0.0012
5 0.0298 nan 0.0500 0.0012
6 0.0281 nan 0.0500 0.0009
7 0.0260 nan 0.0500 0.0023
8 0.0240 nan 0.0500 0.0021
9 0.0218 nan 0.0500 0.0019
10 0.0197 nan 0.0500 0.0013
20 0.0107 nan 0.0500 0.0004
40 0.0040 nan 0.0500 -0.0000
60 0.0013 nan 0.0500 0.0000
80 0.0005 nan 0.0500 -0.0000
100 0.0002 nan 0.0500 -0.0000
120 0.0001 nan 0.0500 0.0000
140 0.0001 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 0.0000
- Fold12: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold12: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0405 nan 0.0500 0.0036
2 0.0388 nan 0.0500 0.0012
3 0.0358 nan 0.0500 0.0021
4 0.0341 nan 0.0500 0.0017
5 0.0308 nan 0.0500 0.0024
6 0.0290 nan 0.0500 0.0015
7 0.0274 nan 0.0500 0.0015
8 0.0257 nan 0.0500 0.0002
9 0.0244 nan 0.0500 0.0010
10 0.0232 nan 0.0500 0.0008
20 0.0132 nan 0.0500 0.0009
40 0.0046 nan 0.0500 0.0002
60 0.0027 nan 0.0500 -0.0000
80 0.0014 nan 0.0500 -0.0000
100 0.0009 nan 0.0500 -0.0000
120 0.0005 nan 0.0500 -0.0000
140 0.0004 nan 0.0500 0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0002 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold12: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold12: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0411 nan 0.0500 0.0027
2 0.0384 nan 0.0500 0.0024
3 0.0366 nan 0.0500 0.0014
4 0.0349 nan 0.0500 0.0010
5 0.0322 nan 0.0500 0.0021
6 0.0310 nan 0.0500 0.0010
7 0.0294 nan 0.0500 0.0018
8 0.0273 nan 0.0500 0.0017
9 0.0263 nan 0.0500 0.0010
10 0.0249 nan 0.0500 0.0007
20 0.0162 nan 0.0500 0.0003
40 0.0080 nan 0.0500 -0.0000
60 0.0047 nan 0.0500 0.0000
80 0.0035 nan 0.0500 -0.0000
100 0.0022 nan 0.0500 -0.0001
120 0.0016 nan 0.0500 -0.0001
140 0.0010 nan 0.0500 0.0000
160 0.0008 nan 0.0500 0.0000
180 0.0006 nan 0.0500 -0.0000
200 0.0004 nan 0.0500 0.0000
- Fold12: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold12: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0379 nan 0.1000 0.0058
2 0.0328 nan 0.1000 0.0049
3 0.0307 nan 0.1000 -0.0007
4 0.0283 nan 0.1000 0.0020
5 0.0265 nan 0.1000 0.0004
6 0.0242 nan 0.1000 0.0013
7 0.0218 nan 0.1000 0.0028
8 0.0202 nan 0.1000 0.0012
9 0.0179 nan 0.1000 0.0014
10 0.0163 nan 0.1000 0.0007
20 0.0075 nan 0.1000 0.0006
40 0.0021 nan 0.1000 0.0000
60 0.0007 nan 0.1000 -0.0000
80 0.0003 nan 0.1000 0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 0.0000
180 0.0000 nan 0.1000 0.0000
200 0.0000 nan 0.1000 0.0000
- Fold12: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold12: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0373 nan 0.1000 0.0057
2 0.0332 nan 0.1000 0.0043
3 0.0314 nan 0.1000 0.0002
4 0.0278 nan 0.1000 0.0020
5 0.0256 nan 0.1000 0.0008
6 0.0228 nan 0.1000 0.0014
7 0.0207 nan 0.1000 0.0010
8 0.0183 nan 0.1000 0.0024
9 0.0165 nan 0.1000 0.0007
10 0.0145 nan 0.1000 0.0017
20 0.0061 nan 0.1000 0.0003
40 0.0019 nan 0.1000 0.0000
60 0.0007 nan 0.1000 -0.0000
80 0.0003 nan 0.1000 -0.0000
100 0.0002 nan 0.1000 -0.0000
120 0.0001 nan 0.1000 0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold12: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold12: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0390 nan 0.1000 0.0039
2 0.0346 nan 0.1000 0.0041
3 0.0302 nan 0.1000 0.0039
4 0.0275 nan 0.1000 0.0008
5 0.0245 nan 0.1000 0.0016
6 0.0225 nan 0.1000 0.0013
7 0.0204 nan 0.1000 -0.0004
8 0.0181 nan 0.1000 0.0017
9 0.0168 nan 0.1000 0.0017
10 0.0150 nan 0.1000 0.0014
20 0.0077 nan 0.1000 0.0002
40 0.0031 nan 0.1000 -0.0002
60 0.0016 nan 0.1000 0.0000
80 0.0009 nan 0.1000 -0.0000
100 0.0004 nan 0.1000 0.0000
120 0.0003 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold12: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold12: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0396 nan 0.1000 0.0004
2 0.0335 nan 0.1000 0.0050
3 0.0283 nan 0.1000 0.0048
4 0.0260 nan 0.1000 -0.0000
5 0.0217 nan 0.1000 0.0037
6 0.0196 nan 0.1000 0.0009
7 0.0176 nan 0.1000 0.0021
8 0.0151 nan 0.1000 0.0016
9 0.0140 nan 0.1000 0.0000
10 0.0123 nan 0.1000 0.0008
20 0.0035 nan 0.1000 -0.0001
40 0.0006 nan 0.1000 0.0000
60 0.0002 nan 0.1000 0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold12: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold12: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0382 nan 0.1000 0.0031
2 0.0350 nan 0.1000 0.0014
3 0.0316 nan 0.1000 0.0003
4 0.0284 nan 0.1000 0.0009
5 0.0238 nan 0.1000 0.0039
6 0.0204 nan 0.1000 0.0034
7 0.0179 nan 0.1000 0.0025
8 0.0157 nan 0.1000 0.0019
9 0.0146 nan 0.1000 0.0004
10 0.0130 nan 0.1000 0.0014
20 0.0044 nan 0.1000 0.0005
40 0.0011 nan 0.1000 0.0000
60 0.0004 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold12: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold12: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0380 nan 0.1000 0.0061
2 0.0336 nan 0.1000 0.0034
3 0.0292 nan 0.1000 0.0032
4 0.0277 nan 0.1000 0.0011
5 0.0261 nan 0.1000 0.0013
6 0.0234 nan 0.1000 0.0027
7 0.0209 nan 0.1000 0.0025
8 0.0189 nan 0.1000 0.0020
9 0.0176 nan 0.1000 0.0009
10 0.0167 nan 0.1000 -0.0008
20 0.0085 nan 0.1000 0.0000
40 0.0037 nan 0.1000 -0.0001
60 0.0018 nan 0.1000 -0.0000
80 0.0009 nan 0.1000 -0.0001
100 0.0005 nan 0.1000 -0.0000
120 0.0003 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 0.0000
160 0.0001 nan 0.1000 0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold12: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold12: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0381 nan 0.1000 0.0028
2 0.0333 nan 0.1000 0.0046
3 0.0289 nan 0.1000 0.0035
4 0.0245 nan 0.1000 0.0048
5 0.0215 nan 0.1000 0.0020
6 0.0193 nan 0.1000 0.0023
7 0.0174 nan 0.1000 0.0017
8 0.0156 nan 0.1000 0.0010
9 0.0130 nan 0.1000 0.0011
10 0.0108 nan 0.1000 0.0013
20 0.0038 nan 0.1000 0.0003
40 0.0008 nan 0.1000 0.0000
60 0.0001 nan 0.1000 -0.0000
80 0.0000 nan 0.1000 0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 0.0000
160 0.0000 nan 0.1000 0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 0.0000
- Fold12: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold12: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0376 nan 0.1000 0.0062
2 0.0338 nan 0.1000 0.0038
3 0.0295 nan 0.1000 0.0032
4 0.0260 nan 0.1000 0.0027
5 0.0234 nan 0.1000 0.0012
6 0.0210 nan 0.1000 0.0027
7 0.0179 nan 0.1000 0.0026
8 0.0148 nan 0.1000 0.0013
9 0.0138 nan 0.1000 -0.0002
10 0.0133 nan 0.1000 -0.0014
20 0.0040 nan 0.1000 0.0003
40 0.0014 nan 0.1000 0.0001
60 0.0006 nan 0.1000 0.0000
80 0.0003 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0001 nan 0.1000 0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold12: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold12: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0378 nan 0.1000 0.0036
2 0.0327 nan 0.1000 0.0044
3 0.0279 nan 0.1000 0.0036
4 0.0255 nan 0.1000 0.0001
5 0.0236 nan 0.1000 0.0015
6 0.0216 nan 0.1000 -0.0005
7 0.0203 nan 0.1000 -0.0011
8 0.0180 nan 0.1000 0.0017
9 0.0157 nan 0.1000 0.0008
10 0.0143 nan 0.1000 0.0011
20 0.0081 nan 0.1000 0.0001
40 0.0029 nan 0.1000 0.0001
60 0.0014 nan 0.1000 -0.0000
80 0.0007 nan 0.1000 0.0000
100 0.0004 nan 0.1000 -0.0000
120 0.0002 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold12: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold13: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0441 nan 0.0100 0.0001
2 0.0435 nan 0.0100 0.0006
3 0.0431 nan 0.0100 0.0003
4 0.0426 nan 0.0100 0.0006
5 0.0419 nan 0.0100 0.0005
6 0.0412 nan 0.0100 0.0005
7 0.0408 nan 0.0100 0.0003
8 0.0404 nan 0.0100 0.0004
9 0.0398 nan 0.0100 0.0006
10 0.0391 nan 0.0100 0.0006
20 0.0347 nan 0.0100 0.0001
40 0.0273 nan 0.0100 0.0002
60 0.0229 nan 0.0100 0.0002
80 0.0188 nan 0.0100 0.0000
100 0.0150 nan 0.0100 0.0001
120 0.0126 nan 0.0100 0.0000
140 0.0105 nan 0.0100 0.0000
160 0.0086 nan 0.0100 0.0000
180 0.0073 nan 0.0100 0.0000
200 0.0063 nan 0.0100 0.0000
- Fold13: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold13: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0437 nan 0.0100 0.0006
2 0.0432 nan 0.0100 0.0003
3 0.0426 nan 0.0100 0.0003
4 0.0421 nan 0.0100 0.0002
5 0.0415 nan 0.0100 0.0005
6 0.0410 nan 0.0100 0.0003
7 0.0406 nan 0.0100 0.0005
8 0.0401 nan 0.0100 0.0005
9 0.0397 nan 0.0100 -0.0000
10 0.0392 nan 0.0100 0.0005
20 0.0350 nan 0.0100 0.0002
40 0.0275 nan 0.0100 0.0002
60 0.0229 nan 0.0100 0.0002
80 0.0185 nan 0.0100 0.0002
100 0.0156 nan 0.0100 -0.0000
120 0.0128 nan 0.0100 0.0001
140 0.0106 nan 0.0100 0.0001
160 0.0091 nan 0.0100 0.0001
180 0.0076 nan 0.0100 0.0001
200 0.0065 nan 0.0100 0.0000
- Fold13: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold13: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0442 nan 0.0100 -0.0001
2 0.0437 nan 0.0100 0.0002
3 0.0432 nan 0.0100 0.0002
4 0.0427 nan 0.0100 0.0006
5 0.0421 nan 0.0100 0.0006
6 0.0416 nan 0.0100 0.0003
7 0.0412 nan 0.0100 0.0003
8 0.0405 nan 0.0100 0.0005
9 0.0398 nan 0.0100 0.0005
10 0.0394 nan 0.0100 0.0003
20 0.0352 nan 0.0100 0.0005
40 0.0280 nan 0.0100 0.0002
60 0.0226 nan 0.0100 0.0003
80 0.0189 nan 0.0100 0.0001
100 0.0156 nan 0.0100 0.0000
120 0.0134 nan 0.0100 0.0000
140 0.0117 nan 0.0100 0.0001
160 0.0102 nan 0.0100 0.0001
180 0.0089 nan 0.0100 0.0001
200 0.0079 nan 0.0100 0.0000
- Fold13: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold13: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0440 nan 0.0100 0.0000
2 0.0433 nan 0.0100 0.0007
3 0.0427 nan 0.0100 0.0005
4 0.0420 nan 0.0100 0.0006
5 0.0414 nan 0.0100 0.0006
6 0.0407 nan 0.0100 0.0004
7 0.0401 nan 0.0100 0.0006
8 0.0395 nan 0.0100 0.0003
9 0.0389 nan 0.0100 0.0007
10 0.0381 nan 0.0100 0.0005
20 0.0334 nan 0.0100 -0.0002
40 0.0254 nan 0.0100 -0.0000
60 0.0191 nan 0.0100 0.0002
80 0.0147 nan 0.0100 0.0000
100 0.0114 nan 0.0100 0.0002
120 0.0089 nan 0.0100 -0.0000
140 0.0072 nan 0.0100 0.0000
160 0.0060 nan 0.0100 0.0000
180 0.0049 nan 0.0100 0.0000
200 0.0040 nan 0.0100 -0.0000
- Fold13: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold13: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0440 nan 0.0100 0.0004
2 0.0432 nan 0.0100 0.0007
3 0.0428 nan 0.0100 0.0006
4 0.0421 nan 0.0100 0.0006
5 0.0416 nan 0.0100 0.0001
6 0.0410 nan 0.0100 0.0004
7 0.0403 nan 0.0100 0.0004
8 0.0400 nan 0.0100 0.0004
9 0.0392 nan 0.0100 0.0004
10 0.0385 nan 0.0100 0.0005
20 0.0337 nan 0.0100 0.0003
40 0.0262 nan 0.0100 0.0001
60 0.0206 nan 0.0100 0.0000
80 0.0168 nan 0.0100 -0.0000
100 0.0133 nan 0.0100 0.0002
120 0.0105 nan 0.0100 0.0000
140 0.0086 nan 0.0100 0.0001
160 0.0070 nan 0.0100 -0.0000
180 0.0058 nan 0.0100 -0.0000
200 0.0047 nan 0.0100 0.0000
- Fold13: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold13: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0440 nan 0.0100 0.0005
2 0.0434 nan 0.0100 0.0006
3 0.0430 nan 0.0100 0.0001
4 0.0427 nan 0.0100 0.0002
5 0.0423 nan 0.0100 -0.0000
6 0.0418 nan 0.0100 0.0006
7 0.0411 nan 0.0100 0.0006
8 0.0407 nan 0.0100 0.0003
9 0.0402 nan 0.0100 0.0001
10 0.0398 nan 0.0100 0.0004
20 0.0356 nan 0.0100 0.0004
40 0.0281 nan 0.0100 0.0003
60 0.0233 nan 0.0100 0.0001
80 0.0190 nan 0.0100 0.0002
100 0.0161 nan 0.0100 0.0001
120 0.0138 nan 0.0100 0.0000
140 0.0120 nan 0.0100 0.0000
160 0.0105 nan 0.0100 0.0000
180 0.0093 nan 0.0100 0.0001
200 0.0084 nan 0.0100 0.0000
- Fold13: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold13: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0436 nan 0.0100 0.0008
2 0.0431 nan 0.0100 0.0004
3 0.0423 nan 0.0100 0.0005
4 0.0418 nan 0.0100 0.0005
5 0.0413 nan 0.0100 0.0004
6 0.0406 nan 0.0100 0.0006
7 0.0397 nan 0.0100 0.0011
8 0.0391 nan 0.0100 0.0004
9 0.0386 nan 0.0100 0.0002
10 0.0382 nan 0.0100 0.0005
20 0.0322 nan 0.0100 0.0005
40 0.0240 nan 0.0100 0.0001
60 0.0182 nan 0.0100 0.0002
80 0.0137 nan 0.0100 0.0002
100 0.0107 nan 0.0100 0.0000
120 0.0084 nan 0.0100 0.0001
140 0.0066 nan 0.0100 0.0000
160 0.0052 nan 0.0100 0.0000
180 0.0041 nan 0.0100 0.0000
200 0.0033 nan 0.0100 0.0000
- Fold13: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold13: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0439 nan 0.0100 0.0006
2 0.0434 nan 0.0100 0.0005
3 0.0428 nan 0.0100 0.0007
4 0.0423 nan 0.0100 0.0004
5 0.0419 nan 0.0100 0.0002
6 0.0414 nan 0.0100 0.0005
7 0.0407 nan 0.0100 0.0005
8 0.0401 nan 0.0100 0.0004
9 0.0395 nan 0.0100 0.0005
10 0.0388 nan 0.0100 0.0006
20 0.0339 nan 0.0100 0.0005
40 0.0264 nan 0.0100 0.0002
60 0.0198 nan 0.0100 0.0001
80 0.0154 nan 0.0100 0.0001
100 0.0119 nan 0.0100 0.0001
120 0.0095 nan 0.0100 0.0001
140 0.0077 nan 0.0100 0.0001
160 0.0062 nan 0.0100 0.0001
180 0.0052 nan 0.0100 0.0000
200 0.0043 nan 0.0100 0.0000
- Fold13: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold13: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0440 nan 0.0100 0.0005
2 0.0433 nan 0.0100 0.0007
3 0.0427 nan 0.0100 0.0006
4 0.0420 nan 0.0100 0.0006
5 0.0414 nan 0.0100 0.0006
6 0.0409 nan 0.0100 0.0005
7 0.0407 nan 0.0100 -0.0000
8 0.0402 nan 0.0100 0.0005
9 0.0397 nan 0.0100 0.0002
10 0.0394 nan 0.0100 0.0001
20 0.0356 nan 0.0100 0.0000
40 0.0287 nan 0.0100 0.0001
60 0.0233 nan 0.0100 0.0003
80 0.0194 nan 0.0100 0.0001
100 0.0162 nan 0.0100 0.0001
120 0.0140 nan 0.0100 0.0001
140 0.0121 nan 0.0100 0.0000
160 0.0104 nan 0.0100 0.0001
180 0.0091 nan 0.0100 0.0001
200 0.0079 nan 0.0100 0.0000
- Fold13: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold13: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0430 nan 0.0500 0.0005
2 0.0400 nan 0.0500 0.0026
3 0.0382 nan 0.0500 0.0011
4 0.0357 nan 0.0500 0.0026
5 0.0334 nan 0.0500 0.0015
6 0.0313 nan 0.0500 0.0019
7 0.0299 nan 0.0500 0.0013
8 0.0277 nan 0.0500 0.0021
9 0.0263 nan 0.0500 0.0015
10 0.0251 nan 0.0500 0.0014
20 0.0144 nan 0.0500 0.0008
40 0.0056 nan 0.0500 0.0001
60 0.0026 nan 0.0500 0.0001
80 0.0014 nan 0.0500 -0.0000
100 0.0008 nan 0.0500 -0.0000
120 0.0005 nan 0.0500 -0.0000
140 0.0003 nan 0.0500 0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 0.0000
- Fold13: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold13: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0420 nan 0.0500 0.0021
2 0.0398 nan 0.0500 0.0023
3 0.0374 nan 0.0500 0.0021
4 0.0352 nan 0.0500 0.0022
5 0.0340 nan 0.0500 0.0001
6 0.0322 nan 0.0500 0.0011
7 0.0304 nan 0.0500 0.0003
8 0.0295 nan 0.0500 -0.0002
9 0.0277 nan 0.0500 0.0003
10 0.0260 nan 0.0500 0.0011
20 0.0163 nan 0.0500 0.0005
40 0.0067 nan 0.0500 0.0001
60 0.0029 nan 0.0500 -0.0000
80 0.0017 nan 0.0500 -0.0001
100 0.0011 nan 0.0500 -0.0000
120 0.0007 nan 0.0500 -0.0000
140 0.0005 nan 0.0500 -0.0000
160 0.0003 nan 0.0500 0.0000
180 0.0002 nan 0.0500 0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold13: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold13: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0415 nan 0.0500 0.0030
2 0.0399 nan 0.0500 0.0018
3 0.0370 nan 0.0500 0.0024
4 0.0346 nan 0.0500 0.0021
5 0.0331 nan 0.0500 0.0012
6 0.0316 nan 0.0500 0.0011
7 0.0302 nan 0.0500 0.0014
8 0.0282 nan 0.0500 0.0019
9 0.0272 nan 0.0500 0.0008
10 0.0258 nan 0.0500 0.0015
20 0.0153 nan 0.0500 0.0004
40 0.0083 nan 0.0500 0.0000
60 0.0051 nan 0.0500 0.0001
80 0.0037 nan 0.0500 -0.0000
100 0.0026 nan 0.0500 -0.0000
120 0.0018 nan 0.0500 -0.0000
140 0.0013 nan 0.0500 -0.0001
160 0.0009 nan 0.0500 0.0000
180 0.0007 nan 0.0500 0.0000
200 0.0005 nan 0.0500 -0.0000
- Fold13: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold13: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0406 nan 0.0500 0.0038
2 0.0376 nan 0.0500 0.0027
3 0.0351 nan 0.0500 0.0019
4 0.0318 nan 0.0500 0.0027
5 0.0290 nan 0.0500 0.0023
6 0.0269 nan 0.0500 0.0006
7 0.0258 nan 0.0500 0.0007
8 0.0238 nan 0.0500 0.0018
9 0.0218 nan 0.0500 0.0013
10 0.0204 nan 0.0500 0.0018
20 0.0108 nan 0.0500 0.0002
40 0.0041 nan 0.0500 0.0000
60 0.0014 nan 0.0500 0.0001
80 0.0005 nan 0.0500 0.0000
100 0.0002 nan 0.0500 -0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0001 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold13: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold13: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0409 nan 0.0500 0.0023
2 0.0392 nan 0.0500 0.0005
3 0.0373 nan 0.0500 0.0015
4 0.0339 nan 0.0500 0.0033
5 0.0309 nan 0.0500 0.0017
6 0.0285 nan 0.0500 0.0015
7 0.0266 nan 0.0500 0.0013
8 0.0245 nan 0.0500 0.0018
9 0.0230 nan 0.0500 0.0015
10 0.0221 nan 0.0500 -0.0000
20 0.0122 nan 0.0500 0.0006
40 0.0050 nan 0.0500 0.0001
60 0.0020 nan 0.0500 -0.0001
80 0.0010 nan 0.0500 0.0000
100 0.0006 nan 0.0500 -0.0000
120 0.0003 nan 0.0500 -0.0000
140 0.0002 nan 0.0500 -0.0000
160 0.0001 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold13: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold13: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0415 nan 0.0500 0.0030
2 0.0385 nan 0.0500 0.0023
3 0.0360 nan 0.0500 0.0021
4 0.0343 nan 0.0500 0.0015
5 0.0320 nan 0.0500 0.0019
6 0.0298 nan 0.0500 0.0021
7 0.0276 nan 0.0500 0.0012
8 0.0257 nan 0.0500 0.0016
9 0.0249 nan 0.0500 0.0009
10 0.0237 nan 0.0500 0.0013
20 0.0158 nan 0.0500 -0.0001
40 0.0090 nan 0.0500 0.0002
60 0.0058 nan 0.0500 0.0001
80 0.0043 nan 0.0500 0.0000
100 0.0029 nan 0.0500 -0.0001
120 0.0020 nan 0.0500 0.0000
140 0.0015 nan 0.0500 0.0000
160 0.0011 nan 0.0500 -0.0001
180 0.0008 nan 0.0500 0.0000
200 0.0007 nan 0.0500 -0.0000
- Fold13: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold13: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0405 nan 0.0500 0.0029
2 0.0379 nan 0.0500 0.0024
3 0.0353 nan 0.0500 0.0013
4 0.0326 nan 0.0500 0.0023
5 0.0301 nan 0.0500 0.0023
6 0.0277 nan 0.0500 0.0018
7 0.0259 nan 0.0500 0.0017
8 0.0240 nan 0.0500 0.0003
9 0.0236 nan 0.0500 -0.0011
10 0.0220 nan 0.0500 0.0021
20 0.0113 nan 0.0500 0.0001
40 0.0032 nan 0.0500 0.0001
60 0.0011 nan 0.0500 0.0000
80 0.0004 nan 0.0500 0.0000
100 0.0002 nan 0.0500 0.0000
120 0.0001 nan 0.0500 0.0000
140 0.0000 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold13: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold13: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0410 nan 0.0500 0.0025
2 0.0377 nan 0.0500 0.0021
3 0.0354 nan 0.0500 0.0020
4 0.0333 nan 0.0500 0.0020
5 0.0313 nan 0.0500 0.0021
6 0.0292 nan 0.0500 0.0015
7 0.0273 nan 0.0500 0.0015
8 0.0259 nan 0.0500 0.0008
9 0.0252 nan 0.0500 0.0006
10 0.0230 nan 0.0500 0.0007
20 0.0129 nan 0.0500 -0.0003
40 0.0046 nan 0.0500 0.0002
60 0.0017 nan 0.0500 0.0000
80 0.0008 nan 0.0500 -0.0000
100 0.0004 nan 0.0500 0.0000
120 0.0002 nan 0.0500 0.0000
140 0.0001 nan 0.0500 0.0000
160 0.0001 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold13: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold13: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0408 nan 0.0500 0.0023
2 0.0397 nan 0.0500 -0.0000
3 0.0364 nan 0.0500 0.0021
4 0.0349 nan 0.0500 -0.0007
5 0.0331 nan 0.0500 0.0017
6 0.0317 nan 0.0500 0.0012
7 0.0302 nan 0.0500 0.0012
8 0.0281 nan 0.0500 0.0021
9 0.0269 nan 0.0500 0.0013
10 0.0250 nan 0.0500 0.0009
20 0.0158 nan 0.0500 0.0006
40 0.0076 nan 0.0500 0.0001
60 0.0050 nan 0.0500 -0.0002
80 0.0033 nan 0.0500 -0.0001
100 0.0025 nan 0.0500 -0.0000
120 0.0018 nan 0.0500 0.0000
140 0.0012 nan 0.0500 -0.0000
160 0.0009 nan 0.0500 0.0000
180 0.0007 nan 0.0500 0.0000
200 0.0005 nan 0.0500 0.0000
- Fold13: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold13: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0390 nan 0.1000 0.0057
2 0.0360 nan 0.1000 0.0005
3 0.0336 nan 0.1000 0.0007
4 0.0300 nan 0.1000 0.0037
5 0.0266 nan 0.1000 0.0035
6 0.0236 nan 0.1000 0.0002
7 0.0217 nan 0.1000 -0.0000
8 0.0192 nan 0.1000 0.0026
9 0.0172 nan 0.1000 0.0016
10 0.0156 nan 0.1000 0.0017
20 0.0057 nan 0.1000 0.0002
40 0.0015 nan 0.1000 -0.0001
60 0.0006 nan 0.1000 -0.0000
80 0.0002 nan 0.1000 0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold13: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold13: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0394 nan 0.1000 0.0060
2 0.0353 nan 0.1000 0.0045
3 0.0317 nan 0.1000 0.0026
4 0.0278 nan 0.1000 0.0019
5 0.0241 nan 0.1000 0.0025
6 0.0211 nan 0.1000 0.0024
7 0.0187 nan 0.1000 0.0003
8 0.0166 nan 0.1000 0.0014
9 0.0143 nan 0.1000 0.0006
10 0.0124 nan 0.1000 0.0017
20 0.0053 nan 0.1000 0.0005
40 0.0020 nan 0.1000 0.0001
60 0.0008 nan 0.1000 -0.0001
80 0.0003 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold13: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold13: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0412 nan 0.1000 0.0022
2 0.0367 nan 0.1000 0.0051
3 0.0317 nan 0.1000 0.0047
4 0.0296 nan 0.1000 0.0010
5 0.0279 nan 0.1000 0.0019
6 0.0247 nan 0.1000 0.0014
7 0.0227 nan 0.1000 0.0012
8 0.0216 nan 0.1000 0.0007
9 0.0191 nan 0.1000 0.0017
10 0.0185 nan 0.1000 -0.0004
20 0.0094 nan 0.1000 0.0001
40 0.0051 nan 0.1000 -0.0002
60 0.0030 nan 0.1000 -0.0001
80 0.0017 nan 0.1000 -0.0000
100 0.0009 nan 0.1000 -0.0000
120 0.0005 nan 0.1000 -0.0000
140 0.0003 nan 0.1000 -0.0000
160 0.0002 nan 0.1000 -0.0000
180 0.0002 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 0.0000
- Fold13: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold13: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0378 nan 0.1000 0.0064
2 0.0327 nan 0.1000 0.0046
3 0.0284 nan 0.1000 0.0004
4 0.0252 nan 0.1000 0.0027
5 0.0220 nan 0.1000 0.0017
6 0.0183 nan 0.1000 0.0029
7 0.0160 nan 0.1000 0.0020
8 0.0150 nan 0.1000 0.0001
9 0.0133 nan 0.1000 0.0014
10 0.0122 nan 0.1000 0.0005
20 0.0039 nan 0.1000 0.0002
40 0.0008 nan 0.1000 -0.0000
60 0.0002 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold13: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold13: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0383 nan 0.1000 0.0064
2 0.0340 nan 0.1000 0.0046
3 0.0301 nan 0.1000 0.0029
4 0.0262 nan 0.1000 0.0046
5 0.0235 nan 0.1000 -0.0002
6 0.0205 nan 0.1000 0.0014
7 0.0185 nan 0.1000 0.0014
8 0.0156 nan 0.1000 0.0022
9 0.0135 nan 0.1000 0.0010
10 0.0120 nan 0.1000 0.0009
20 0.0036 nan 0.1000 -0.0001
40 0.0010 nan 0.1000 -0.0000
60 0.0003 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold13: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold13: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0385 nan 0.1000 0.0033
2 0.0345 nan 0.1000 0.0022
3 0.0330 nan 0.1000 -0.0004
4 0.0287 nan 0.1000 0.0038
5 0.0256 nan 0.1000 0.0019
6 0.0226 nan 0.1000 0.0029
7 0.0195 nan 0.1000 0.0020
8 0.0179 nan 0.1000 -0.0011
9 0.0165 nan 0.1000 0.0010
10 0.0151 nan 0.1000 0.0017
20 0.0086 nan 0.1000 0.0006
40 0.0030 nan 0.1000 0.0001
60 0.0015 nan 0.1000 -0.0000
80 0.0007 nan 0.1000 -0.0000
100 0.0004 nan 0.1000 -0.0000
120 0.0002 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold13: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold13: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0371 nan 0.1000 0.0061
2 0.0324 nan 0.1000 0.0047
3 0.0287 nan 0.1000 0.0026
4 0.0247 nan 0.1000 0.0022
5 0.0219 nan 0.1000 0.0008
6 0.0187 nan 0.1000 0.0026
7 0.0165 nan 0.1000 0.0000
8 0.0146 nan 0.1000 0.0017
9 0.0120 nan 0.1000 0.0019
10 0.0100 nan 0.1000 0.0007
20 0.0036 nan 0.1000 0.0001
40 0.0008 nan 0.1000 -0.0000
60 0.0002 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 0.0000
120 0.0000 nan 0.1000 0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold13: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold13: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0374 nan 0.1000 0.0060
2 0.0325 nan 0.1000 0.0045
3 0.0271 nan 0.1000 0.0039
4 0.0223 nan 0.1000 0.0041
5 0.0188 nan 0.1000 0.0030
6 0.0170 nan 0.1000 0.0015
7 0.0152 nan 0.1000 0.0017
8 0.0145 nan 0.1000 -0.0008
9 0.0133 nan 0.1000 0.0007
10 0.0125 nan 0.1000 0.0008
20 0.0039 nan 0.1000 0.0004
40 0.0013 nan 0.1000 0.0000
60 0.0004 nan 0.1000 0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold13: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold13: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0386 nan 0.1000 0.0060
2 0.0355 nan 0.1000 0.0025
3 0.0308 nan 0.1000 0.0043
4 0.0266 nan 0.1000 0.0032
5 0.0240 nan 0.1000 0.0030
6 0.0233 nan 0.1000 0.0004
7 0.0225 nan 0.1000 -0.0000
8 0.0206 nan 0.1000 0.0020
9 0.0190 nan 0.1000 0.0001
10 0.0170 nan 0.1000 0.0018
20 0.0083 nan 0.1000 0.0000
40 0.0039 nan 0.1000 -0.0002
60 0.0020 nan 0.1000 0.0000
80 0.0012 nan 0.1000 0.0001
100 0.0007 nan 0.1000 -0.0000
120 0.0005 nan 0.1000 -0.0000
140 0.0004 nan 0.1000 -0.0000
160 0.0002 nan 0.1000 -0.0000
180 0.0002 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold13: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold14: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0430 nan 0.0100 0.0006
2 0.0428 nan 0.0100 -0.0001
3 0.0426 nan 0.0100 0.0000
4 0.0421 nan 0.0100 0.0005
5 0.0416 nan 0.0100 0.0005
6 0.0409 nan 0.0100 0.0005
7 0.0404 nan 0.0100 0.0006
8 0.0398 nan 0.0100 0.0005
9 0.0393 nan 0.0100 0.0004
10 0.0388 nan 0.0100 0.0001
20 0.0348 nan 0.0100 0.0003
40 0.0276 nan 0.0100 0.0003
60 0.0223 nan 0.0100 0.0002
80 0.0179 nan 0.0100 0.0000
100 0.0149 nan 0.0100 0.0000
120 0.0125 nan 0.0100 -0.0000
140 0.0105 nan 0.0100 0.0001
160 0.0088 nan 0.0100 0.0001
180 0.0075 nan 0.0100 0.0001
200 0.0064 nan 0.0100 0.0001
- Fold14: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold14: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0431 nan 0.0100 0.0005
2 0.0426 nan 0.0100 0.0004
3 0.0421 nan 0.0100 0.0002
4 0.0416 nan 0.0100 0.0005
5 0.0410 nan 0.0100 0.0006
6 0.0403 nan 0.0100 0.0006
7 0.0398 nan 0.0100 0.0003
8 0.0393 nan 0.0100 0.0004
9 0.0390 nan 0.0100 0.0003
10 0.0387 nan 0.0100 0.0004
20 0.0342 nan 0.0100 0.0003
40 0.0271 nan 0.0100 0.0003
60 0.0218 nan 0.0100 0.0003
80 0.0176 nan 0.0100 0.0001
100 0.0144 nan 0.0100 0.0001
120 0.0118 nan 0.0100 0.0001
140 0.0100 nan 0.0100 0.0000
160 0.0084 nan 0.0100 0.0000
180 0.0071 nan 0.0100 0.0000
200 0.0062 nan 0.0100 0.0000
- Fold14: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold14: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0432 nan 0.0100 0.0004
2 0.0427 nan 0.0100 0.0004
3 0.0423 nan 0.0100 0.0005
4 0.0416 nan 0.0100 0.0005
5 0.0412 nan 0.0100 0.0002
6 0.0407 nan 0.0100 0.0004
7 0.0401 nan 0.0100 0.0005
8 0.0397 nan 0.0100 0.0003
9 0.0394 nan 0.0100 0.0001
10 0.0389 nan 0.0100 0.0005
20 0.0349 nan 0.0100 0.0002
40 0.0281 nan 0.0100 0.0001
60 0.0228 nan 0.0100 0.0001
80 0.0187 nan 0.0100 0.0001
100 0.0158 nan 0.0100 0.0001
120 0.0135 nan 0.0100 0.0000
140 0.0117 nan 0.0100 0.0000
160 0.0100 nan 0.0100 0.0001
180 0.0086 nan 0.0100 -0.0001
200 0.0077 nan 0.0100 0.0000
- Fold14: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold14: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0430 nan 0.0100 0.0007
2 0.0426 nan 0.0100 0.0003
3 0.0419 nan 0.0100 0.0005
4 0.0414 nan 0.0100 0.0004
5 0.0408 nan 0.0100 0.0005
6 0.0402 nan 0.0100 0.0002
7 0.0396 nan 0.0100 0.0007
8 0.0388 nan 0.0100 0.0011
9 0.0383 nan 0.0100 0.0004
10 0.0375 nan 0.0100 0.0007
20 0.0328 nan 0.0100 0.0006
40 0.0256 nan 0.0100 0.0003
60 0.0201 nan 0.0100 0.0000
80 0.0156 nan 0.0100 0.0002
100 0.0126 nan 0.0100 0.0000
120 0.0100 nan 0.0100 0.0001
140 0.0078 nan 0.0100 0.0001
160 0.0062 nan 0.0100 0.0001
180 0.0049 nan 0.0100 0.0001
200 0.0040 nan 0.0100 0.0000
- Fold14: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold14: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0430 nan 0.0100 0.0007
2 0.0425 nan 0.0100 0.0006
3 0.0419 nan 0.0100 0.0006
4 0.0413 nan 0.0100 0.0005
5 0.0406 nan 0.0100 0.0006
6 0.0400 nan 0.0100 0.0005
7 0.0394 nan 0.0100 0.0003
8 0.0388 nan 0.0100 0.0002
9 0.0382 nan 0.0100 0.0004
10 0.0375 nan 0.0100 0.0005
20 0.0325 nan 0.0100 0.0004
40 0.0250 nan 0.0100 -0.0000
60 0.0194 nan 0.0100 0.0002
80 0.0151 nan 0.0100 0.0002
100 0.0117 nan 0.0100 0.0001
120 0.0095 nan 0.0100 0.0001
140 0.0076 nan 0.0100 0.0001
160 0.0062 nan 0.0100 -0.0001
180 0.0050 nan 0.0100 0.0000
200 0.0041 nan 0.0100 -0.0000
- Fold14: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold14: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0431 nan 0.0100 0.0005
2 0.0428 nan 0.0100 0.0000
3 0.0423 nan 0.0100 0.0003
4 0.0419 nan 0.0100 0.0004
5 0.0413 nan 0.0100 0.0006
6 0.0407 nan 0.0100 0.0006
7 0.0403 nan 0.0100 0.0005
8 0.0398 nan 0.0100 0.0005
9 0.0394 nan 0.0100 0.0003
10 0.0392 nan 0.0100 0.0002
20 0.0348 nan 0.0100 0.0003
40 0.0283 nan 0.0100 0.0002
60 0.0228 nan 0.0100 0.0002
80 0.0187 nan 0.0100 0.0002
100 0.0157 nan 0.0100 -0.0000
120 0.0136 nan 0.0100 0.0000
140 0.0117 nan 0.0100 0.0000
160 0.0103 nan 0.0100 0.0001
180 0.0091 nan 0.0100 -0.0000
200 0.0080 nan 0.0100 0.0000
- Fold14: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold14: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0431 nan 0.0100 0.0002
2 0.0423 nan 0.0100 0.0007
3 0.0417 nan 0.0100 0.0005
4 0.0409 nan 0.0100 0.0007
5 0.0406 nan 0.0100 -0.0002
6 0.0399 nan 0.0100 0.0006
7 0.0393 nan 0.0100 0.0004
8 0.0385 nan 0.0100 0.0005
9 0.0378 nan 0.0100 0.0006
10 0.0374 nan 0.0100 0.0004
20 0.0319 nan 0.0100 0.0005
40 0.0241 nan 0.0100 0.0000
60 0.0184 nan 0.0100 0.0003
80 0.0139 nan 0.0100 0.0001
100 0.0105 nan 0.0100 0.0001
120 0.0080 nan 0.0100 0.0000
140 0.0062 nan 0.0100 0.0000
160 0.0049 nan 0.0100 0.0000
180 0.0038 nan 0.0100 0.0000
200 0.0030 nan 0.0100 0.0000
- Fold14: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold14: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0429 nan 0.0100 0.0004
2 0.0421 nan 0.0100 0.0007
3 0.0412 nan 0.0100 0.0005
4 0.0407 nan 0.0100 0.0006
5 0.0400 nan 0.0100 0.0007
6 0.0396 nan 0.0100 0.0002
7 0.0388 nan 0.0100 0.0005
8 0.0383 nan 0.0100 0.0005
9 0.0377 nan 0.0100 0.0005
10 0.0370 nan 0.0100 0.0006
20 0.0324 nan 0.0100 0.0002
40 0.0246 nan 0.0100 0.0003
60 0.0190 nan 0.0100 0.0002
80 0.0145 nan 0.0100 0.0002
100 0.0113 nan 0.0100 0.0000
120 0.0090 nan 0.0100 -0.0000
140 0.0072 nan 0.0100 0.0000
160 0.0059 nan 0.0100 -0.0000
180 0.0048 nan 0.0100 0.0000
200 0.0040 nan 0.0100 -0.0000
- Fold14: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold14: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0432 nan 0.0100 0.0005
2 0.0428 nan 0.0100 0.0003
3 0.0422 nan 0.0100 0.0006
4 0.0418 nan 0.0100 0.0003
5 0.0412 nan 0.0100 0.0006
6 0.0409 nan 0.0100 0.0002
7 0.0405 nan 0.0100 0.0005
8 0.0402 nan 0.0100 0.0002
9 0.0399 nan 0.0100 0.0002
10 0.0397 nan 0.0100 0.0001
20 0.0354 nan 0.0100 0.0004
40 0.0286 nan 0.0100 0.0003
60 0.0234 nan 0.0100 0.0001
80 0.0194 nan 0.0100 0.0001
100 0.0164 nan 0.0100 0.0001
120 0.0141 nan 0.0100 0.0000
140 0.0123 nan 0.0100 0.0000
160 0.0106 nan 0.0100 0.0001
180 0.0095 nan 0.0100 0.0000
200 0.0084 nan 0.0100 0.0000
- Fold14: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold14: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0405 nan 0.0500 0.0022
2 0.0384 nan 0.0500 0.0024
3 0.0365 nan 0.0500 0.0018
4 0.0344 nan 0.0500 0.0018
5 0.0337 nan 0.0500 -0.0006
6 0.0313 nan 0.0500 0.0022
7 0.0300 nan 0.0500 -0.0003
8 0.0279 nan 0.0500 0.0020
9 0.0263 nan 0.0500 0.0015
10 0.0250 nan 0.0500 0.0013
20 0.0155 nan 0.0500 0.0004
40 0.0065 nan 0.0500 0.0001
60 0.0031 nan 0.0500 0.0000
80 0.0018 nan 0.0500 0.0001
100 0.0010 nan 0.0500 0.0000
120 0.0006 nan 0.0500 -0.0000
140 0.0004 nan 0.0500 -0.0000
160 0.0003 nan 0.0500 -0.0000
180 0.0002 nan 0.0500 0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold14: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold14: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0415 nan 0.0500 0.0014
2 0.0387 nan 0.0500 0.0014
3 0.0362 nan 0.0500 0.0027
4 0.0346 nan 0.0500 0.0015
5 0.0327 nan 0.0500 0.0002
6 0.0304 nan 0.0500 0.0018
7 0.0285 nan 0.0500 0.0021
8 0.0269 nan 0.0500 0.0018
9 0.0255 nan 0.0500 0.0003
10 0.0238 nan 0.0500 0.0015
20 0.0149 nan 0.0500 0.0008
40 0.0065 nan 0.0500 0.0002
60 0.0034 nan 0.0500 -0.0000
80 0.0021 nan 0.0500 -0.0000
100 0.0013 nan 0.0500 0.0000
120 0.0009 nan 0.0500 -0.0000
140 0.0005 nan 0.0500 -0.0000
160 0.0003 nan 0.0500 -0.0000
180 0.0002 nan 0.0500 -0.0000
200 0.0002 nan 0.0500 0.0000
- Fold14: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold14: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0428 nan 0.0500 -0.0004
2 0.0416 nan 0.0500 0.0006
3 0.0387 nan 0.0500 0.0027
4 0.0370 nan 0.0500 0.0020
5 0.0346 nan 0.0500 0.0023
6 0.0324 nan 0.0500 0.0019
7 0.0303 nan 0.0500 0.0019
8 0.0295 nan 0.0500 0.0006
9 0.0286 nan 0.0500 0.0011
10 0.0269 nan 0.0500 0.0015
20 0.0170 nan 0.0500 0.0006
40 0.0088 nan 0.0500 -0.0000
60 0.0055 nan 0.0500 -0.0002
80 0.0033 nan 0.0500 0.0001
100 0.0021 nan 0.0500 0.0000
120 0.0016 nan 0.0500 0.0000
140 0.0013 nan 0.0500 0.0000
160 0.0009 nan 0.0500 0.0000
180 0.0006 nan 0.0500 0.0000
200 0.0005 nan 0.0500 -0.0000
- Fold14: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold14: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0400 nan 0.0500 0.0023
2 0.0363 nan 0.0500 0.0032
3 0.0336 nan 0.0500 0.0013
4 0.0313 nan 0.0500 0.0018
5 0.0301 nan 0.0500 0.0009
6 0.0276 nan 0.0500 0.0011
7 0.0260 nan 0.0500 0.0014
8 0.0236 nan 0.0500 0.0024
9 0.0226 nan 0.0500 0.0008
10 0.0213 nan 0.0500 0.0008
20 0.0115 nan 0.0500 0.0002
40 0.0046 nan 0.0500 -0.0001
60 0.0018 nan 0.0500 0.0001
80 0.0009 nan 0.0500 0.0000
100 0.0005 nan 0.0500 0.0000
120 0.0002 nan 0.0500 -0.0000
140 0.0001 nan 0.0500 0.0000
160 0.0001 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold14: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold14: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0400 nan 0.0500 0.0033
2 0.0374 nan 0.0500 0.0024
3 0.0350 nan 0.0500 0.0013
4 0.0332 nan 0.0500 0.0017
5 0.0306 nan 0.0500 0.0017
6 0.0284 nan 0.0500 0.0017
7 0.0259 nan 0.0500 0.0014
8 0.0240 nan 0.0500 0.0016
9 0.0227 nan 0.0500 0.0012
10 0.0214 nan 0.0500 0.0015
20 0.0105 nan 0.0500 0.0006
40 0.0037 nan 0.0500 0.0000
60 0.0015 nan 0.0500 0.0000
80 0.0008 nan 0.0500 -0.0000
100 0.0005 nan 0.0500 -0.0000
120 0.0002 nan 0.0500 -0.0000
140 0.0001 nan 0.0500 0.0000
160 0.0001 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold14: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold14: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0400 nan 0.0500 0.0026
2 0.0376 nan 0.0500 0.0020
3 0.0353 nan 0.0500 0.0007
4 0.0337 nan 0.0500 0.0016
5 0.0315 nan 0.0500 0.0006
6 0.0293 nan 0.0500 0.0008
7 0.0277 nan 0.0500 0.0015
8 0.0257 nan 0.0500 0.0016
9 0.0239 nan 0.0500 0.0016
10 0.0235 nan 0.0500 0.0000
20 0.0153 nan 0.0500 -0.0002
40 0.0089 nan 0.0500 0.0001
60 0.0051 nan 0.0500 0.0001
80 0.0034 nan 0.0500 0.0000
100 0.0024 nan 0.0500 0.0000
120 0.0017 nan 0.0500 -0.0000
140 0.0011 nan 0.0500 0.0000
160 0.0008 nan 0.0500 -0.0000
180 0.0005 nan 0.0500 -0.0000
200 0.0003 nan 0.0500 0.0000
- Fold14: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold14: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0401 nan 0.0500 0.0023
2 0.0381 nan 0.0500 0.0017
3 0.0355 nan 0.0500 0.0019
4 0.0328 nan 0.0500 0.0004
5 0.0302 nan 0.0500 0.0017
6 0.0280 nan 0.0500 0.0006
7 0.0262 nan 0.0500 0.0009
8 0.0244 nan 0.0500 0.0018
9 0.0234 nan 0.0500 0.0002
10 0.0225 nan 0.0500 0.0002
20 0.0103 nan 0.0500 0.0007
40 0.0031 nan 0.0500 0.0000
60 0.0012 nan 0.0500 -0.0000
80 0.0005 nan 0.0500 -0.0000
100 0.0002 nan 0.0500 -0.0000
120 0.0001 nan 0.0500 0.0000
140 0.0000 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold14: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold14: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0400 nan 0.0500 0.0027
2 0.0374 nan 0.0500 0.0015
3 0.0341 nan 0.0500 0.0021
4 0.0315 nan 0.0500 0.0015
5 0.0288 nan 0.0500 0.0022
6 0.0273 nan 0.0500 0.0009
7 0.0252 nan 0.0500 0.0019
8 0.0233 nan 0.0500 0.0013
9 0.0214 nan 0.0500 0.0015
10 0.0195 nan 0.0500 0.0009
20 0.0117 nan 0.0500 -0.0000
40 0.0037 nan 0.0500 0.0001
60 0.0013 nan 0.0500 0.0001
80 0.0006 nan 0.0500 -0.0000
100 0.0003 nan 0.0500 0.0000
120 0.0002 nan 0.0500 0.0000
140 0.0001 nan 0.0500 -0.0000
160 0.0001 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 0.0000
- Fold14: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold14: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0410 nan 0.0500 0.0010
2 0.0388 nan 0.0500 0.0023
3 0.0363 nan 0.0500 0.0027
4 0.0345 nan 0.0500 0.0009
5 0.0320 nan 0.0500 0.0023
6 0.0307 nan 0.0500 0.0013
7 0.0289 nan 0.0500 0.0019
8 0.0275 nan 0.0500 0.0016
9 0.0268 nan 0.0500 -0.0003
10 0.0255 nan 0.0500 0.0014
20 0.0172 nan 0.0500 -0.0001
40 0.0079 nan 0.0500 0.0001
60 0.0051 nan 0.0500 -0.0001
80 0.0037 nan 0.0500 -0.0001
100 0.0027 nan 0.0500 -0.0000
120 0.0018 nan 0.0500 0.0000
140 0.0013 nan 0.0500 0.0000
160 0.0009 nan 0.0500 0.0000
180 0.0006 nan 0.0500 -0.0000
200 0.0005 nan 0.0500 -0.0000
- Fold14: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold14: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0393 nan 0.1000 0.0054
2 0.0338 nan 0.1000 0.0052
3 0.0311 nan 0.1000 0.0027
4 0.0276 nan 0.1000 0.0018
5 0.0236 nan 0.1000 0.0033
6 0.0205 nan 0.1000 0.0013
7 0.0183 nan 0.1000 0.0001
8 0.0160 nan 0.1000 0.0018
9 0.0145 nan 0.1000 0.0006
10 0.0126 nan 0.1000 0.0012
20 0.0052 nan 0.1000 0.0002
40 0.0014 nan 0.1000 -0.0001
60 0.0005 nan 0.1000 -0.0000
80 0.0002 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold14: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold14: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0374 nan 0.1000 0.0045
2 0.0320 nan 0.1000 0.0030
3 0.0279 nan 0.1000 0.0040
4 0.0258 nan 0.1000 0.0015
5 0.0238 nan 0.1000 0.0014
6 0.0213 nan 0.1000 0.0024
7 0.0194 nan 0.1000 0.0007
8 0.0183 nan 0.1000 0.0005
9 0.0165 nan 0.1000 0.0019
10 0.0151 nan 0.1000 0.0010
20 0.0057 nan 0.1000 0.0005
40 0.0016 nan 0.1000 -0.0000
60 0.0005 nan 0.1000 -0.0000
80 0.0002 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold14: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold14: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0379 nan 0.1000 0.0050
2 0.0341 nan 0.1000 0.0040
3 0.0318 nan 0.1000 0.0020
4 0.0291 nan 0.1000 0.0006
5 0.0250 nan 0.1000 0.0029
6 0.0221 nan 0.1000 0.0028
7 0.0205 nan 0.1000 0.0015
8 0.0190 nan 0.1000 0.0018
9 0.0178 nan 0.1000 0.0004
10 0.0169 nan 0.1000 0.0008
20 0.0101 nan 0.1000 0.0002
40 0.0046 nan 0.1000 -0.0003
60 0.0018 nan 0.1000 0.0000
80 0.0009 nan 0.1000 0.0000
100 0.0005 nan 0.1000 0.0000
120 0.0003 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold14: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold14: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0371 nan 0.1000 0.0046
2 0.0322 nan 0.1000 0.0048
3 0.0264 nan 0.1000 0.0040
4 0.0255 nan 0.1000 0.0004
5 0.0230 nan 0.1000 0.0002
6 0.0195 nan 0.1000 0.0028
7 0.0169 nan 0.1000 0.0014
8 0.0154 nan 0.1000 0.0014
9 0.0125 nan 0.1000 0.0020
10 0.0118 nan 0.1000 -0.0001
20 0.0045 nan 0.1000 0.0002
40 0.0009 nan 0.1000 0.0000
60 0.0002 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 0.0000
180 0.0000 nan 0.1000 0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold14: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold14: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0392 nan 0.1000 0.0033
2 0.0359 nan 0.1000 0.0038
3 0.0315 nan 0.1000 0.0042
4 0.0268 nan 0.1000 0.0028
5 0.0244 nan 0.1000 0.0017
6 0.0230 nan 0.1000 0.0017
7 0.0201 nan 0.1000 0.0028
8 0.0186 nan 0.1000 0.0007
9 0.0170 nan 0.1000 0.0011
10 0.0147 nan 0.1000 0.0015
20 0.0064 nan 0.1000 0.0002
40 0.0010 nan 0.1000 -0.0000
60 0.0002 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold14: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold14: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0391 nan 0.1000 0.0050
2 0.0342 nan 0.1000 0.0020
3 0.0296 nan 0.1000 0.0034
4 0.0267 nan 0.1000 0.0024
5 0.0237 nan 0.1000 0.0028
6 0.0211 nan 0.1000 0.0022
7 0.0193 nan 0.1000 0.0019
8 0.0167 nan 0.1000 0.0018
9 0.0155 nan 0.1000 0.0007
10 0.0148 nan 0.1000 0.0002
20 0.0072 nan 0.1000 0.0002
40 0.0029 nan 0.1000 -0.0001
60 0.0015 nan 0.1000 -0.0000
80 0.0009 nan 0.1000 -0.0000
100 0.0005 nan 0.1000 -0.0000
120 0.0003 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 0.0000
- Fold14: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold14: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0356 nan 0.1000 0.0056
2 0.0307 nan 0.1000 0.0033
3 0.0257 nan 0.1000 0.0047
4 0.0242 nan 0.1000 -0.0000
5 0.0204 nan 0.1000 0.0015
6 0.0171 nan 0.1000 0.0023
7 0.0150 nan 0.1000 0.0011
8 0.0137 nan 0.1000 0.0006
9 0.0114 nan 0.1000 0.0008
10 0.0102 nan 0.1000 0.0014
20 0.0033 nan 0.1000 0.0001
40 0.0004 nan 0.1000 0.0000
60 0.0001 nan 0.1000 0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold14: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold14: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0377 nan 0.1000 0.0057
2 0.0328 nan 0.1000 0.0055
3 0.0282 nan 0.1000 0.0017
4 0.0247 nan 0.1000 0.0020
5 0.0207 nan 0.1000 0.0034
6 0.0185 nan 0.1000 0.0016
7 0.0164 nan 0.1000 0.0009
8 0.0143 nan 0.1000 0.0022
9 0.0127 nan 0.1000 0.0007
10 0.0110 nan 0.1000 0.0011
20 0.0035 nan 0.1000 0.0002
40 0.0008 nan 0.1000 -0.0001
60 0.0002 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold14: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold14: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0402 nan 0.1000 0.0021
2 0.0346 nan 0.1000 0.0052
3 0.0304 nan 0.1000 0.0033
4 0.0266 nan 0.1000 0.0035
5 0.0246 nan 0.1000 0.0007
6 0.0220 nan 0.1000 0.0017
7 0.0207 nan 0.1000 0.0007
8 0.0197 nan 0.1000 0.0002
9 0.0183 nan 0.1000 -0.0001
10 0.0168 nan 0.1000 0.0004
20 0.0097 nan 0.1000 -0.0002
40 0.0037 nan 0.1000 -0.0002
60 0.0014 nan 0.1000 -0.0001
80 0.0008 nan 0.1000 -0.0000
100 0.0005 nan 0.1000 -0.0000
120 0.0003 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 0.0000
- Fold14: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold15: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0366 nan 0.0100 0.0005
2 0.0361 nan 0.0100 0.0004
3 0.0356 nan 0.0100 0.0001
4 0.0352 nan 0.0100 0.0001
5 0.0347 nan 0.0100 0.0005
6 0.0343 nan 0.0100 0.0004
7 0.0338 nan 0.0100 0.0004
8 0.0334 nan 0.0100 0.0003
9 0.0328 nan 0.0100 0.0005
10 0.0324 nan 0.0100 0.0003
20 0.0286 nan 0.0100 0.0004
40 0.0225 nan 0.0100 0.0001
60 0.0185 nan 0.0100 0.0002
80 0.0154 nan 0.0100 0.0001
100 0.0129 nan 0.0100 0.0000
120 0.0106 nan 0.0100 -0.0000
140 0.0089 nan 0.0100 0.0000
160 0.0077 nan 0.0100 0.0000
180 0.0066 nan 0.0100 0.0000
200 0.0056 nan 0.0100 0.0000
- Fold15: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold15: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0365 nan 0.0100 0.0005
2 0.0360 nan 0.0100 0.0005
3 0.0354 nan 0.0100 0.0004
4 0.0350 nan 0.0100 0.0003
5 0.0347 nan 0.0100 0.0002
6 0.0343 nan 0.0100 0.0005
7 0.0340 nan 0.0100 0.0004
8 0.0337 nan 0.0100 0.0000
9 0.0333 nan 0.0100 0.0001
10 0.0331 nan 0.0100 0.0001
20 0.0296 nan 0.0100 0.0002
40 0.0235 nan 0.0100 0.0003
60 0.0192 nan 0.0100 0.0002
80 0.0158 nan 0.0100 -0.0001
100 0.0131 nan 0.0100 -0.0000
120 0.0109 nan 0.0100 -0.0000
140 0.0093 nan 0.0100 -0.0001
160 0.0078 nan 0.0100 0.0001
180 0.0067 nan 0.0100 0.0001
200 0.0058 nan 0.0100 0.0000
- Fold15: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold15: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0367 nan 0.0100 0.0003
2 0.0362 nan 0.0100 0.0002
3 0.0358 nan 0.0100 0.0005
4 0.0353 nan 0.0100 0.0004
5 0.0347 nan 0.0100 0.0005
6 0.0343 nan 0.0100 0.0003
7 0.0338 nan 0.0100 0.0004
8 0.0334 nan 0.0100 0.0003
9 0.0331 nan 0.0100 0.0002
10 0.0329 nan 0.0100 0.0001
20 0.0292 nan 0.0100 0.0000
40 0.0228 nan 0.0100 0.0002
60 0.0187 nan 0.0100 0.0002
80 0.0155 nan 0.0100 0.0001
100 0.0129 nan 0.0100 0.0001
120 0.0110 nan 0.0100 0.0000
140 0.0095 nan 0.0100 -0.0000
160 0.0082 nan 0.0100 -0.0000
180 0.0073 nan 0.0100 -0.0000
200 0.0065 nan 0.0100 0.0000
- Fold15: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold15: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0366 nan 0.0100 0.0002
2 0.0362 nan 0.0100 0.0001
3 0.0358 nan 0.0100 0.0004
4 0.0354 nan 0.0100 0.0002
5 0.0350 nan 0.0100 0.0004
6 0.0347 nan 0.0100 0.0003
7 0.0342 nan 0.0100 0.0004
8 0.0337 nan 0.0100 0.0001
9 0.0332 nan 0.0100 0.0001
10 0.0329 nan 0.0100 0.0000
20 0.0291 nan 0.0100 0.0002
40 0.0218 nan 0.0100 0.0003
60 0.0173 nan 0.0100 0.0001
80 0.0139 nan 0.0100 -0.0000
100 0.0110 nan 0.0100 0.0001
120 0.0088 nan 0.0100 0.0001
140 0.0069 nan 0.0100 0.0001
160 0.0055 nan 0.0100 -0.0000
180 0.0045 nan 0.0100 0.0000
200 0.0037 nan 0.0100 0.0000
- Fold15: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold15: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0365 nan 0.0100 0.0005
2 0.0359 nan 0.0100 0.0005
3 0.0355 nan 0.0100 0.0001
4 0.0351 nan 0.0100 0.0004
5 0.0345 nan 0.0100 0.0004
6 0.0341 nan 0.0100 0.0002
7 0.0338 nan 0.0100 0.0004
8 0.0332 nan 0.0100 0.0004
9 0.0328 nan 0.0100 0.0004
10 0.0322 nan 0.0100 0.0004
20 0.0285 nan 0.0100 0.0003
40 0.0218 nan 0.0100 0.0002
60 0.0169 nan 0.0100 0.0001
80 0.0135 nan 0.0100 -0.0000
100 0.0108 nan 0.0100 -0.0000
120 0.0089 nan 0.0100 0.0001
140 0.0073 nan 0.0100 0.0000
160 0.0060 nan 0.0100 0.0000
180 0.0050 nan 0.0100 0.0000
200 0.0042 nan 0.0100 -0.0000
- Fold15: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold15: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0367 nan 0.0100 0.0005
2 0.0364 nan 0.0100 0.0002
3 0.0358 nan 0.0100 0.0004
4 0.0354 nan 0.0100 0.0003
5 0.0349 nan 0.0100 0.0005
6 0.0345 nan 0.0100 0.0004
7 0.0339 nan 0.0100 0.0004
8 0.0336 nan 0.0100 0.0003
9 0.0331 nan 0.0100 0.0003
10 0.0328 nan 0.0100 0.0002
20 0.0296 nan 0.0100 -0.0001
40 0.0240 nan 0.0100 0.0003
60 0.0196 nan 0.0100 0.0001
80 0.0159 nan 0.0100 0.0001
100 0.0132 nan 0.0100 0.0001
120 0.0114 nan 0.0100 0.0001
140 0.0102 nan 0.0100 0.0001
160 0.0089 nan 0.0100 -0.0000
180 0.0080 nan 0.0100 -0.0000
200 0.0072 nan 0.0100 -0.0000
- Fold15: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold15: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0365 nan 0.0100 0.0007
2 0.0358 nan 0.0100 0.0006
3 0.0350 nan 0.0100 0.0005
4 0.0343 nan 0.0100 0.0003
5 0.0338 nan 0.0100 0.0005
6 0.0331 nan 0.0100 0.0006
7 0.0328 nan 0.0100 0.0000
8 0.0322 nan 0.0100 0.0004
9 0.0318 nan 0.0100 0.0002
10 0.0313 nan 0.0100 0.0002
20 0.0274 nan 0.0100 0.0002
40 0.0207 nan 0.0100 0.0002
60 0.0159 nan 0.0100 -0.0000
80 0.0122 nan 0.0100 0.0001
100 0.0094 nan 0.0100 -0.0000
120 0.0074 nan 0.0100 0.0001
140 0.0058 nan 0.0100 0.0001
160 0.0045 nan 0.0100 0.0000
180 0.0036 nan 0.0100 0.0000
200 0.0029 nan 0.0100 0.0000
- Fold15: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold15: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0365 nan 0.0100 0.0004
2 0.0358 nan 0.0100 0.0006
3 0.0353 nan 0.0100 0.0004
4 0.0347 nan 0.0100 0.0005
5 0.0342 nan 0.0100 0.0005
6 0.0339 nan 0.0100 0.0001
7 0.0334 nan 0.0100 0.0001
8 0.0329 nan 0.0100 0.0005
9 0.0325 nan 0.0100 0.0003
10 0.0321 nan 0.0100 0.0004
20 0.0280 nan 0.0100 0.0002
40 0.0215 nan 0.0100 0.0003
60 0.0173 nan 0.0100 0.0000
80 0.0136 nan 0.0100 0.0001
100 0.0105 nan 0.0100 0.0001
120 0.0084 nan 0.0100 0.0001
140 0.0070 nan 0.0100 0.0001
160 0.0057 nan 0.0100 0.0000
180 0.0048 nan 0.0100 0.0000
200 0.0040 nan 0.0100 0.0000
- Fold15: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold15: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0367 nan 0.0100 0.0004
2 0.0363 nan 0.0100 0.0004
3 0.0359 nan 0.0100 0.0003
4 0.0355 nan 0.0100 0.0005
5 0.0349 nan 0.0100 0.0005
6 0.0345 nan 0.0100 0.0002
7 0.0339 nan 0.0100 0.0005
8 0.0335 nan 0.0100 0.0002
9 0.0333 nan 0.0100 -0.0000
10 0.0329 nan 0.0100 0.0004
20 0.0292 nan 0.0100 0.0003
40 0.0237 nan 0.0100 0.0000
60 0.0194 nan 0.0100 0.0001
80 0.0160 nan 0.0100 0.0001
100 0.0137 nan 0.0100 0.0001
120 0.0118 nan 0.0100 0.0000
140 0.0102 nan 0.0100 -0.0001
160 0.0090 nan 0.0100 0.0000
180 0.0079 nan 0.0100 0.0000
200 0.0070 nan 0.0100 -0.0000
- Fold15: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold15: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0347 nan 0.0500 0.0024
2 0.0334 nan 0.0500 0.0013
3 0.0317 nan 0.0500 0.0020
4 0.0300 nan 0.0500 0.0012
5 0.0283 nan 0.0500 0.0015
6 0.0265 nan 0.0500 0.0016
7 0.0245 nan 0.0500 0.0012
8 0.0230 nan 0.0500 0.0014
9 0.0218 nan 0.0500 0.0004
10 0.0205 nan 0.0500 0.0006
20 0.0125 nan 0.0500 0.0003
40 0.0058 nan 0.0500 0.0002
60 0.0028 nan 0.0500 -0.0001
80 0.0015 nan 0.0500 -0.0000
100 0.0009 nan 0.0500 -0.0000
120 0.0005 nan 0.0500 -0.0000
140 0.0003 nan 0.0500 0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold15: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold15: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0346 nan 0.0500 0.0022
2 0.0319 nan 0.0500 0.0016
3 0.0290 nan 0.0500 0.0020
4 0.0274 nan 0.0500 0.0009
5 0.0258 nan 0.0500 0.0016
6 0.0249 nan 0.0500 0.0009
7 0.0236 nan 0.0500 0.0013
8 0.0222 nan 0.0500 0.0014
9 0.0209 nan 0.0500 0.0009
10 0.0197 nan 0.0500 0.0011
20 0.0131 nan 0.0500 -0.0002
40 0.0061 nan 0.0500 0.0001
60 0.0032 nan 0.0500 0.0001
80 0.0019 nan 0.0500 -0.0001
100 0.0011 nan 0.0500 -0.0000
120 0.0007 nan 0.0500 0.0000
140 0.0005 nan 0.0500 -0.0000
160 0.0003 nan 0.0500 0.0000
180 0.0002 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 0.0000
- Fold15: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold15: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0349 nan 0.0500 0.0022
2 0.0337 nan 0.0500 -0.0006
3 0.0315 nan 0.0500 0.0017
4 0.0292 nan 0.0500 0.0020
5 0.0275 nan 0.0500 0.0018
6 0.0262 nan 0.0500 0.0016
7 0.0250 nan 0.0500 0.0015
8 0.0248 nan 0.0500 -0.0009
9 0.0233 nan 0.0500 0.0004
10 0.0224 nan 0.0500 0.0007
20 0.0141 nan 0.0500 0.0004
40 0.0084 nan 0.0500 -0.0000
60 0.0056 nan 0.0500 0.0001
80 0.0041 nan 0.0500 0.0000
100 0.0030 nan 0.0500 -0.0001
120 0.0023 nan 0.0500 -0.0000
140 0.0019 nan 0.0500 -0.0000
160 0.0016 nan 0.0500 -0.0000
180 0.0013 nan 0.0500 -0.0000
200 0.0009 nan 0.0500 -0.0000
- Fold15: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold15: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0346 nan 0.0500 0.0026
2 0.0324 nan 0.0500 0.0019
3 0.0311 nan 0.0500 -0.0005
4 0.0292 nan 0.0500 0.0003
5 0.0277 nan 0.0500 0.0000
6 0.0262 nan 0.0500 0.0008
7 0.0240 nan 0.0500 0.0016
8 0.0220 nan 0.0500 0.0016
9 0.0202 nan 0.0500 0.0012
10 0.0189 nan 0.0500 0.0012
20 0.0107 nan 0.0500 0.0004
40 0.0035 nan 0.0500 0.0001
60 0.0015 nan 0.0500 -0.0001
80 0.0007 nan 0.0500 -0.0000
100 0.0004 nan 0.0500 -0.0000
120 0.0002 nan 0.0500 0.0000
140 0.0001 nan 0.0500 -0.0000
160 0.0001 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold15: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold15: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0348 nan 0.0500 0.0022
2 0.0326 nan 0.0500 0.0025
3 0.0301 nan 0.0500 0.0018
4 0.0285 nan 0.0500 0.0009
5 0.0260 nan 0.0500 0.0018
6 0.0253 nan 0.0500 -0.0005
7 0.0237 nan 0.0500 0.0017
8 0.0230 nan 0.0500 0.0004
9 0.0217 nan 0.0500 0.0009
10 0.0203 nan 0.0500 0.0014
20 0.0110 nan 0.0500 0.0002
40 0.0041 nan 0.0500 0.0001
60 0.0019 nan 0.0500 0.0000
80 0.0010 nan 0.0500 -0.0000
100 0.0007 nan 0.0500 -0.0000
120 0.0004 nan 0.0500 0.0000
140 0.0003 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 0.0000
- Fold15: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold15: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0350 nan 0.0500 0.0012
2 0.0339 nan 0.0500 0.0000
3 0.0315 nan 0.0500 0.0022
4 0.0294 nan 0.0500 0.0019
5 0.0281 nan 0.0500 0.0008
6 0.0265 nan 0.0500 0.0018
7 0.0248 nan 0.0500 0.0014
8 0.0228 nan 0.0500 0.0015
9 0.0222 nan 0.0500 -0.0002
10 0.0210 nan 0.0500 0.0006
20 0.0128 nan 0.0500 0.0006
40 0.0077 nan 0.0500 0.0001
60 0.0048 nan 0.0500 -0.0000
80 0.0034 nan 0.0500 0.0001
100 0.0026 nan 0.0500 -0.0001
120 0.0018 nan 0.0500 0.0000
140 0.0014 nan 0.0500 0.0000
160 0.0011 nan 0.0500 -0.0000
180 0.0008 nan 0.0500 -0.0000
200 0.0007 nan 0.0500 -0.0000
- Fold15: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold15: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0340 nan 0.0500 0.0023
2 0.0314 nan 0.0500 0.0009
3 0.0288 nan 0.0500 0.0020
4 0.0261 nan 0.0500 0.0024
5 0.0239 nan 0.0500 0.0016
6 0.0233 nan 0.0500 0.0003
7 0.0217 nan 0.0500 0.0014
8 0.0209 nan 0.0500 0.0002
9 0.0194 nan 0.0500 0.0014
10 0.0181 nan 0.0500 0.0012
20 0.0096 nan 0.0500 0.0006
40 0.0029 nan 0.0500 0.0000
60 0.0011 nan 0.0500 0.0000
80 0.0005 nan 0.0500 0.0000
100 0.0002 nan 0.0500 -0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0001 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 0.0000
- Fold15: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold15: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0355 nan 0.0500 0.0006
2 0.0338 nan 0.0500 0.0013
3 0.0324 nan 0.0500 0.0008
4 0.0301 nan 0.0500 0.0016
5 0.0279 nan 0.0500 0.0019
6 0.0263 nan 0.0500 0.0010
7 0.0243 nan 0.0500 0.0012
8 0.0223 nan 0.0500 0.0015
9 0.0212 nan 0.0500 0.0006
10 0.0200 nan 0.0500 0.0008
20 0.0114 nan 0.0500 0.0005
40 0.0042 nan 0.0500 -0.0000
60 0.0020 nan 0.0500 0.0000
80 0.0010 nan 0.0500 -0.0000
100 0.0006 nan 0.0500 0.0000
120 0.0005 nan 0.0500 -0.0000
140 0.0004 nan 0.0500 -0.0000
160 0.0003 nan 0.0500 0.0000
180 0.0002 nan 0.0500 -0.0000
200 0.0002 nan 0.0500 -0.0000
- Fold15: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold15: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0352 nan 0.0500 0.0009
2 0.0329 nan 0.0500 0.0018
3 0.0315 nan 0.0500 0.0018
4 0.0292 nan 0.0500 0.0020
5 0.0273 nan 0.0500 0.0017
6 0.0261 nan 0.0500 0.0008
7 0.0244 nan 0.0500 0.0007
8 0.0225 nan 0.0500 0.0014
9 0.0211 nan 0.0500 0.0012
10 0.0201 nan 0.0500 0.0007
20 0.0144 nan 0.0500 -0.0004
40 0.0076 nan 0.0500 0.0001
60 0.0051 nan 0.0500 -0.0000
80 0.0036 nan 0.0500 -0.0000
100 0.0026 nan 0.0500 0.0000
120 0.0019 nan 0.0500 0.0000
140 0.0014 nan 0.0500 -0.0000
160 0.0010 nan 0.0500 -0.0000
180 0.0009 nan 0.0500 -0.0000
200 0.0007 nan 0.0500 -0.0000
- Fold15: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold15: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0337 nan 0.1000 0.0035
2 0.0312 nan 0.1000 0.0014
3 0.0271 nan 0.1000 0.0037
4 0.0242 nan 0.1000 0.0005
5 0.0231 nan 0.1000 0.0000
6 0.0206 nan 0.1000 0.0011
7 0.0183 nan 0.1000 0.0013
8 0.0172 nan 0.1000 -0.0000
9 0.0155 nan 0.1000 0.0016
10 0.0137 nan 0.1000 0.0005
20 0.0060 nan 0.1000 -0.0001
40 0.0015 nan 0.1000 0.0000
60 0.0006 nan 0.1000 -0.0000
80 0.0002 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold15: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold15: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0350 nan 0.1000 -0.0012
2 0.0318 nan 0.1000 0.0014
3 0.0284 nan 0.1000 0.0017
4 0.0242 nan 0.1000 0.0035
5 0.0228 nan 0.1000 0.0003
6 0.0199 nan 0.1000 0.0015
7 0.0178 nan 0.1000 0.0024
8 0.0158 nan 0.1000 0.0013
9 0.0146 nan 0.1000 0.0010
10 0.0130 nan 0.1000 0.0005
20 0.0057 nan 0.1000 0.0000
40 0.0022 nan 0.1000 -0.0002
60 0.0010 nan 0.1000 0.0000
80 0.0005 nan 0.1000 -0.0000
100 0.0002 nan 0.1000 0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold15: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold15: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0330 nan 0.1000 0.0039
2 0.0292 nan 0.1000 0.0037
3 0.0263 nan 0.1000 0.0013
4 0.0229 nan 0.1000 0.0033
5 0.0198 nan 0.1000 0.0027
6 0.0181 nan 0.1000 0.0016
7 0.0160 nan 0.1000 0.0019
8 0.0150 nan 0.1000 0.0008
9 0.0134 nan 0.1000 0.0009
10 0.0119 nan 0.1000 0.0013
20 0.0066 nan 0.1000 0.0003
40 0.0035 nan 0.1000 -0.0000
60 0.0019 nan 0.1000 -0.0000
80 0.0012 nan 0.1000 -0.0000
100 0.0008 nan 0.1000 0.0000
120 0.0005 nan 0.1000 -0.0000
140 0.0003 nan 0.1000 0.0000
160 0.0002 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold15: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold15: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0327 nan 0.1000 0.0042
2 0.0272 nan 0.1000 0.0029
3 0.0235 nan 0.1000 0.0028
4 0.0200 nan 0.1000 0.0035
5 0.0174 nan 0.1000 0.0013
6 0.0150 nan 0.1000 0.0015
7 0.0135 nan 0.1000 0.0010
8 0.0115 nan 0.1000 0.0014
9 0.0098 nan 0.1000 0.0006
10 0.0086 nan 0.1000 0.0007
20 0.0029 nan 0.1000 -0.0001
40 0.0005 nan 0.1000 0.0000
60 0.0002 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold15: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold15: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0316 nan 0.1000 0.0046
2 0.0277 nan 0.1000 0.0034
3 0.0233 nan 0.1000 0.0033
4 0.0211 nan 0.1000 0.0018
5 0.0180 nan 0.1000 0.0016
6 0.0161 nan 0.1000 0.0016
7 0.0141 nan 0.1000 0.0011
8 0.0130 nan 0.1000 0.0008
9 0.0116 nan 0.1000 0.0006
10 0.0107 nan 0.1000 0.0007
20 0.0038 nan 0.1000 -0.0001
40 0.0012 nan 0.1000 0.0000
60 0.0004 nan 0.1000 -0.0000
80 0.0002 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 0.0000
160 0.0000 nan 0.1000 0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 0.0000
- Fold15: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold15: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0347 nan 0.1000 0.0005
2 0.0300 nan 0.1000 0.0045
3 0.0256 nan 0.1000 0.0035
4 0.0232 nan 0.1000 0.0019
5 0.0216 nan 0.1000 0.0014
6 0.0206 nan 0.1000 0.0004
7 0.0192 nan 0.1000 0.0006
8 0.0169 nan 0.1000 0.0015
9 0.0164 nan 0.1000 -0.0001
10 0.0147 nan 0.1000 0.0010
20 0.0076 nan 0.1000 -0.0003
40 0.0035 nan 0.1000 0.0001
60 0.0016 nan 0.1000 -0.0000
80 0.0009 nan 0.1000 -0.0000
100 0.0006 nan 0.1000 -0.0000
120 0.0004 nan 0.1000 0.0000
140 0.0003 nan 0.1000 -0.0000
160 0.0002 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold15: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold15: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0318 nan 0.1000 0.0030
2 0.0284 nan 0.1000 0.0022
3 0.0245 nan 0.1000 0.0038
4 0.0200 nan 0.1000 0.0026
5 0.0170 nan 0.1000 0.0019
6 0.0148 nan 0.1000 0.0009
7 0.0136 nan 0.1000 0.0007
8 0.0116 nan 0.1000 0.0021
9 0.0102 nan 0.1000 0.0015
10 0.0088 nan 0.1000 0.0010
20 0.0025 nan 0.1000 0.0000
40 0.0004 nan 0.1000 -0.0000
60 0.0001 nan 0.1000 -0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold15: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold15: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0313 nan 0.1000 0.0025
2 0.0272 nan 0.1000 0.0041
3 0.0231 nan 0.1000 0.0043
4 0.0201 nan 0.1000 0.0024
5 0.0173 nan 0.1000 0.0016
6 0.0147 nan 0.1000 0.0019
7 0.0133 nan 0.1000 0.0004
8 0.0121 nan 0.1000 0.0012
9 0.0102 nan 0.1000 0.0007
10 0.0093 nan 0.1000 0.0009
20 0.0031 nan 0.1000 0.0001
40 0.0009 nan 0.1000 -0.0000
60 0.0003 nan 0.1000 -0.0000
80 0.0002 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold15: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold15: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0318 nan 0.1000 0.0043
2 0.0290 nan 0.1000 0.0028
3 0.0252 nan 0.1000 0.0034
4 0.0219 nan 0.1000 0.0024
5 0.0194 nan 0.1000 0.0026
6 0.0173 nan 0.1000 0.0003
7 0.0161 nan 0.1000 0.0009
8 0.0139 nan 0.1000 0.0009
9 0.0129 nan 0.1000 0.0007
10 0.0119 nan 0.1000 0.0009
20 0.0063 nan 0.1000 0.0002
40 0.0028 nan 0.1000 -0.0001
60 0.0016 nan 0.1000 -0.0001
80 0.0009 nan 0.1000 0.0000
100 0.0005 nan 0.1000 -0.0000
120 0.0003 nan 0.1000 0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold15: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold16: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0432 nan 0.0100 0.0006
2 0.0425 nan 0.0100 0.0006
3 0.0419 nan 0.0100 0.0004
4 0.0413 nan 0.0100 0.0005
5 0.0407 nan 0.0100 0.0003
6 0.0403 nan 0.0100 0.0004
7 0.0397 nan 0.0100 0.0004
8 0.0392 nan 0.0100 0.0003
9 0.0387 nan 0.0100 0.0002
10 0.0384 nan 0.0100 0.0003
20 0.0339 nan 0.0100 0.0004
40 0.0268 nan 0.0100 -0.0000
60 0.0218 nan 0.0100 0.0003
80 0.0181 nan 0.0100 0.0000
100 0.0147 nan 0.0100 0.0001
120 0.0123 nan 0.0100 0.0001
140 0.0103 nan 0.0100 0.0001
160 0.0090 nan 0.0100 0.0001
180 0.0076 nan 0.0100 0.0000
200 0.0065 nan 0.0100 0.0000
- Fold16: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold16: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0434 nan 0.0100 0.0000
2 0.0428 nan 0.0100 0.0005
3 0.0423 nan 0.0100 0.0006
4 0.0417 nan 0.0100 0.0005
5 0.0413 nan 0.0100 0.0001
6 0.0409 nan 0.0100 0.0003
7 0.0404 nan 0.0100 0.0002
8 0.0399 nan 0.0100 0.0003
9 0.0393 nan 0.0100 0.0006
10 0.0389 nan 0.0100 0.0002
20 0.0346 nan 0.0100 0.0002
40 0.0276 nan 0.0100 0.0003
60 0.0227 nan 0.0100 0.0002
80 0.0185 nan 0.0100 0.0001
100 0.0152 nan 0.0100 0.0001
120 0.0127 nan 0.0100 0.0001
140 0.0107 nan 0.0100 0.0001
160 0.0091 nan 0.0100 -0.0001
180 0.0079 nan 0.0100 0.0001
200 0.0069 nan 0.0100 0.0000
- Fold16: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold16: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0433 nan 0.0100 0.0002
2 0.0428 nan 0.0100 0.0002
3 0.0423 nan 0.0100 0.0002
4 0.0418 nan 0.0100 0.0003
5 0.0412 nan 0.0100 0.0005
6 0.0407 nan 0.0100 0.0005
7 0.0402 nan 0.0100 0.0003
8 0.0397 nan 0.0100 0.0003
9 0.0393 nan 0.0100 0.0003
10 0.0388 nan 0.0100 0.0002
20 0.0345 nan 0.0100 0.0002
40 0.0279 nan 0.0100 0.0004
60 0.0224 nan 0.0100 0.0001
80 0.0190 nan 0.0100 0.0002
100 0.0161 nan 0.0100 0.0000
120 0.0139 nan 0.0100 0.0001
140 0.0121 nan 0.0100 0.0001
160 0.0108 nan 0.0100 0.0001
180 0.0098 nan 0.0100 0.0000
200 0.0087 nan 0.0100 0.0000
- Fold16: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold16: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0434 nan 0.0100 0.0000
2 0.0430 nan 0.0100 0.0005
3 0.0423 nan 0.0100 0.0004
4 0.0419 nan 0.0100 0.0002
5 0.0414 nan 0.0100 0.0003
6 0.0411 nan 0.0100 -0.0000
7 0.0405 nan 0.0100 0.0002
8 0.0399 nan 0.0100 0.0003
9 0.0395 nan 0.0100 0.0001
10 0.0390 nan 0.0100 0.0004
20 0.0335 nan 0.0100 0.0005
40 0.0256 nan 0.0100 0.0004
60 0.0195 nan 0.0100 0.0002
80 0.0150 nan 0.0100 0.0001
100 0.0117 nan 0.0100 0.0000
120 0.0092 nan 0.0100 0.0001
140 0.0072 nan 0.0100 0.0001
160 0.0058 nan 0.0100 0.0000
180 0.0048 nan 0.0100 0.0000
200 0.0039 nan 0.0100 0.0000
- Fold16: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold16: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0434 nan 0.0100 -0.0000
2 0.0428 nan 0.0100 0.0005
3 0.0422 nan 0.0100 0.0007
4 0.0416 nan 0.0100 0.0005
5 0.0411 nan 0.0100 0.0004
6 0.0405 nan 0.0100 0.0003
7 0.0398 nan 0.0100 0.0006
8 0.0392 nan 0.0100 0.0006
9 0.0388 nan 0.0100 0.0003
10 0.0384 nan 0.0100 0.0003
20 0.0336 nan 0.0100 0.0004
40 0.0258 nan 0.0100 0.0003
60 0.0199 nan 0.0100 0.0002
80 0.0158 nan 0.0100 0.0001
100 0.0129 nan 0.0100 0.0001
120 0.0104 nan 0.0100 0.0000
140 0.0083 nan 0.0100 -0.0000
160 0.0068 nan 0.0100 0.0001
180 0.0055 nan 0.0100 0.0000
200 0.0046 nan 0.0100 0.0001
- Fold16: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold16: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0431 nan 0.0100 0.0005
2 0.0426 nan 0.0100 0.0006
3 0.0423 nan 0.0100 -0.0000
4 0.0419 nan 0.0100 0.0003
5 0.0414 nan 0.0100 0.0002
6 0.0411 nan 0.0100 -0.0000
7 0.0405 nan 0.0100 0.0005
8 0.0400 nan 0.0100 0.0004
9 0.0395 nan 0.0100 0.0003
10 0.0391 nan 0.0100 0.0004
20 0.0355 nan 0.0100 0.0003
40 0.0277 nan 0.0100 0.0003
60 0.0228 nan 0.0100 0.0002
80 0.0187 nan 0.0100 -0.0001
100 0.0160 nan 0.0100 0.0001
120 0.0138 nan 0.0100 0.0001
140 0.0119 nan 0.0100 0.0000
160 0.0104 nan 0.0100 0.0000
180 0.0089 nan 0.0100 0.0000
200 0.0079 nan 0.0100 0.0000
- Fold16: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold16: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0431 nan 0.0100 0.0006
2 0.0425 nan 0.0100 0.0003
3 0.0419 nan 0.0100 0.0002
4 0.0411 nan 0.0100 0.0006
5 0.0407 nan 0.0100 0.0003
6 0.0402 nan 0.0100 0.0006
7 0.0397 nan 0.0100 0.0006
8 0.0389 nan 0.0100 0.0008
9 0.0382 nan 0.0100 0.0007
10 0.0376 nan 0.0100 0.0004
20 0.0324 nan 0.0100 0.0003
40 0.0240 nan 0.0100 0.0001
60 0.0177 nan 0.0100 0.0001
80 0.0136 nan 0.0100 0.0002
100 0.0105 nan 0.0100 0.0000
120 0.0083 nan 0.0100 0.0001
140 0.0065 nan 0.0100 0.0001
160 0.0050 nan 0.0100 0.0001
180 0.0040 nan 0.0100 0.0000
200 0.0031 nan 0.0100 0.0000
- Fold16: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold16: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0430 nan 0.0100 0.0004
2 0.0422 nan 0.0100 0.0005
3 0.0417 nan 0.0100 0.0006
4 0.0411 nan 0.0100 0.0007
5 0.0404 nan 0.0100 0.0006
6 0.0398 nan 0.0100 0.0003
7 0.0392 nan 0.0100 0.0003
8 0.0387 nan 0.0100 0.0003
9 0.0382 nan 0.0100 0.0006
10 0.0375 nan 0.0100 0.0005
20 0.0323 nan 0.0100 0.0004
40 0.0248 nan 0.0100 0.0003
60 0.0195 nan 0.0100 0.0000
80 0.0151 nan 0.0100 0.0000
100 0.0122 nan 0.0100 0.0000
120 0.0097 nan 0.0100 0.0000
140 0.0076 nan 0.0100 0.0001
160 0.0061 nan 0.0100 0.0000
180 0.0049 nan 0.0100 0.0000
200 0.0042 nan 0.0100 0.0000
- Fold16: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold16: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0433 nan 0.0100 0.0005
2 0.0426 nan 0.0100 0.0005
3 0.0420 nan 0.0100 0.0005
4 0.0416 nan 0.0100 0.0004
5 0.0411 nan 0.0100 0.0003
6 0.0406 nan 0.0100 0.0005
7 0.0400 nan 0.0100 0.0006
8 0.0395 nan 0.0100 0.0004
9 0.0393 nan 0.0100 0.0000
10 0.0389 nan 0.0100 0.0004
20 0.0351 nan 0.0100 0.0004
40 0.0279 nan 0.0100 0.0001
60 0.0229 nan 0.0100 0.0002
80 0.0195 nan 0.0100 0.0000
100 0.0167 nan 0.0100 -0.0000
120 0.0142 nan 0.0100 0.0001
140 0.0123 nan 0.0100 0.0000
160 0.0109 nan 0.0100 -0.0000
180 0.0096 nan 0.0100 0.0000
200 0.0086 nan 0.0100 0.0000
- Fold16: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold16: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0419 nan 0.0500 0.0009
2 0.0397 nan 0.0500 0.0021
3 0.0373 nan 0.0500 0.0025
4 0.0351 nan 0.0500 0.0012
5 0.0329 nan 0.0500 0.0020
6 0.0306 nan 0.0500 0.0015
7 0.0284 nan 0.0500 0.0021
8 0.0272 nan 0.0500 0.0008
9 0.0266 nan 0.0500 0.0000
10 0.0248 nan 0.0500 0.0015
20 0.0155 nan 0.0500 0.0004
40 0.0067 nan 0.0500 0.0001
60 0.0031 nan 0.0500 0.0000
80 0.0018 nan 0.0500 0.0000
100 0.0010 nan 0.0500 0.0000
120 0.0006 nan 0.0500 -0.0000
140 0.0004 nan 0.0500 -0.0000
160 0.0003 nan 0.0500 -0.0000
180 0.0002 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold16: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold16: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0414 nan 0.0500 0.0026
2 0.0385 nan 0.0500 0.0020
3 0.0362 nan 0.0500 0.0007
4 0.0344 nan 0.0500 0.0018
5 0.0319 nan 0.0500 0.0023
6 0.0299 nan 0.0500 0.0021
7 0.0279 nan 0.0500 0.0017
8 0.0262 nan 0.0500 0.0017
9 0.0250 nan 0.0500 0.0003
10 0.0239 nan 0.0500 0.0001
20 0.0137 nan 0.0500 0.0005
40 0.0059 nan 0.0500 0.0001
60 0.0031 nan 0.0500 0.0001
80 0.0018 nan 0.0500 -0.0000
100 0.0011 nan 0.0500 -0.0000
120 0.0006 nan 0.0500 0.0000
140 0.0004 nan 0.0500 0.0000
160 0.0003 nan 0.0500 -0.0000
180 0.0002 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 0.0000
- Fold16: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold16: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0420 nan 0.0500 0.0012
2 0.0392 nan 0.0500 0.0027
3 0.0368 nan 0.0500 0.0019
4 0.0349 nan 0.0500 0.0022
5 0.0328 nan 0.0500 0.0021
6 0.0310 nan 0.0500 0.0007
7 0.0286 nan 0.0500 0.0016
8 0.0276 nan 0.0500 0.0005
9 0.0258 nan 0.0500 0.0014
10 0.0247 nan 0.0500 0.0001
20 0.0141 nan 0.0500 0.0004
40 0.0075 nan 0.0500 0.0000
60 0.0045 nan 0.0500 -0.0001
80 0.0029 nan 0.0500 0.0000
100 0.0019 nan 0.0500 -0.0000
120 0.0013 nan 0.0500 -0.0000
140 0.0009 nan 0.0500 -0.0000
160 0.0006 nan 0.0500 -0.0000
180 0.0004 nan 0.0500 0.0000
200 0.0003 nan 0.0500 -0.0000
- Fold16: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold16: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0405 nan 0.0500 0.0010
2 0.0383 nan 0.0500 0.0016
3 0.0359 nan 0.0500 0.0020
4 0.0325 nan 0.0500 0.0028
5 0.0308 nan 0.0500 0.0008
6 0.0290 nan 0.0500 0.0015
7 0.0267 nan 0.0500 0.0018
8 0.0252 nan 0.0500 0.0003
9 0.0234 nan 0.0500 0.0005
10 0.0220 nan 0.0500 0.0011
20 0.0127 nan 0.0500 0.0004
40 0.0046 nan 0.0500 -0.0000
60 0.0020 nan 0.0500 0.0000
80 0.0008 nan 0.0500 -0.0001
100 0.0004 nan 0.0500 -0.0000
120 0.0002 nan 0.0500 0.0000
140 0.0001 nan 0.0500 0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 0.0000
- Fold16: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold16: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0394 nan 0.0500 0.0028
2 0.0377 nan 0.0500 0.0011
3 0.0350 nan 0.0500 0.0031
4 0.0327 nan 0.0500 0.0012
5 0.0307 nan 0.0500 0.0019
6 0.0286 nan 0.0500 0.0014
7 0.0265 nan 0.0500 0.0018
8 0.0244 nan 0.0500 0.0016
9 0.0227 nan 0.0500 0.0001
10 0.0211 nan 0.0500 0.0014
20 0.0116 nan 0.0500 0.0008
40 0.0038 nan 0.0500 0.0002
60 0.0018 nan 0.0500 0.0000
80 0.0009 nan 0.0500 0.0000
100 0.0005 nan 0.0500 -0.0000
120 0.0003 nan 0.0500 -0.0000
140 0.0002 nan 0.0500 -0.0000
160 0.0001 nan 0.0500 0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 0.0000
- Fold16: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold16: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0411 nan 0.0500 0.0022
2 0.0388 nan 0.0500 0.0015
3 0.0360 nan 0.0500 0.0026
4 0.0337 nan 0.0500 0.0022
5 0.0326 nan 0.0500 -0.0002
6 0.0315 nan 0.0500 0.0011
7 0.0298 nan 0.0500 0.0010
8 0.0289 nan 0.0500 0.0012
9 0.0275 nan 0.0500 0.0009
10 0.0260 nan 0.0500 0.0013
20 0.0155 nan 0.0500 0.0003
40 0.0082 nan 0.0500 0.0001
60 0.0049 nan 0.0500 0.0001
80 0.0033 nan 0.0500 0.0000
100 0.0023 nan 0.0500 -0.0001
120 0.0017 nan 0.0500 -0.0000
140 0.0013 nan 0.0500 0.0000
160 0.0011 nan 0.0500 0.0000
180 0.0008 nan 0.0500 -0.0000
200 0.0007 nan 0.0500 -0.0000
- Fold16: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold16: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0413 nan 0.0500 0.0025
2 0.0378 nan 0.0500 0.0031
3 0.0368 nan 0.0500 -0.0007
4 0.0350 nan 0.0500 -0.0001
5 0.0334 nan 0.0500 0.0007
6 0.0313 nan 0.0500 0.0012
7 0.0304 nan 0.0500 0.0006
8 0.0282 nan 0.0500 0.0023
9 0.0264 nan 0.0500 0.0012
10 0.0240 nan 0.0500 0.0018
20 0.0116 nan 0.0500 0.0002
40 0.0038 nan 0.0500 -0.0000
60 0.0013 nan 0.0500 0.0000
80 0.0005 nan 0.0500 0.0000
100 0.0002 nan 0.0500 -0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0000 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold16: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold16: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0410 nan 0.0500 0.0023
2 0.0382 nan 0.0500 0.0022
3 0.0356 nan 0.0500 0.0024
4 0.0326 nan 0.0500 0.0018
5 0.0294 nan 0.0500 0.0023
6 0.0276 nan 0.0500 0.0008
7 0.0250 nan 0.0500 0.0019
8 0.0242 nan 0.0500 0.0006
9 0.0232 nan 0.0500 0.0008
10 0.0220 nan 0.0500 0.0008
20 0.0120 nan 0.0500 0.0007
40 0.0043 nan 0.0500 0.0002
60 0.0019 nan 0.0500 -0.0001
80 0.0010 nan 0.0500 0.0000
100 0.0006 nan 0.0500 -0.0000
120 0.0004 nan 0.0500 -0.0000
140 0.0003 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 0.0000
- Fold16: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold16: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0407 nan 0.0500 0.0022
2 0.0384 nan 0.0500 0.0020
3 0.0369 nan 0.0500 0.0008
4 0.0347 nan 0.0500 0.0019
5 0.0330 nan 0.0500 0.0009
6 0.0306 nan 0.0500 0.0018
7 0.0298 nan 0.0500 -0.0005
8 0.0281 nan 0.0500 0.0010
9 0.0274 nan 0.0500 -0.0002
10 0.0259 nan 0.0500 0.0010
20 0.0157 nan 0.0500 0.0003
40 0.0074 nan 0.0500 0.0002
60 0.0043 nan 0.0500 -0.0002
80 0.0029 nan 0.0500 -0.0000
100 0.0018 nan 0.0500 -0.0000
120 0.0012 nan 0.0500 0.0000
140 0.0009 nan 0.0500 -0.0000
160 0.0007 nan 0.0500 0.0000
180 0.0005 nan 0.0500 -0.0000
200 0.0004 nan 0.0500 -0.0000
- Fold16: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold16: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0397 nan 0.1000 0.0036
2 0.0367 nan 0.1000 0.0027
3 0.0344 nan 0.1000 -0.0003
4 0.0310 nan 0.1000 0.0013
5 0.0278 nan 0.1000 0.0006
6 0.0253 nan 0.1000 0.0030
7 0.0223 nan 0.1000 0.0024
8 0.0204 nan 0.1000 0.0022
9 0.0181 nan 0.1000 0.0006
10 0.0165 nan 0.1000 0.0009
20 0.0073 nan 0.1000 0.0005
40 0.0023 nan 0.1000 0.0000
60 0.0008 nan 0.1000 -0.0001
80 0.0003 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold16: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold16: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0392 nan 0.1000 0.0053
2 0.0342 nan 0.1000 0.0047
3 0.0320 nan 0.1000 0.0016
4 0.0294 nan 0.1000 0.0029
5 0.0262 nan 0.1000 0.0027
6 0.0237 nan 0.1000 0.0023
7 0.0218 nan 0.1000 0.0015
8 0.0193 nan 0.1000 0.0021
9 0.0174 nan 0.1000 0.0019
10 0.0160 nan 0.1000 0.0012
20 0.0072 nan 0.1000 -0.0002
40 0.0024 nan 0.1000 -0.0000
60 0.0009 nan 0.1000 0.0000
80 0.0004 nan 0.1000 0.0000
100 0.0002 nan 0.1000 -0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 0.0000
160 0.0000 nan 0.1000 0.0000
180 0.0000 nan 0.1000 0.0000
200 0.0000 nan 0.1000 0.0000
- Fold16: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold16: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0371 nan 0.1000 0.0056
2 0.0335 nan 0.1000 0.0018
3 0.0294 nan 0.1000 0.0023
4 0.0277 nan 0.1000 -0.0004
5 0.0243 nan 0.1000 0.0031
6 0.0230 nan 0.1000 -0.0003
7 0.0205 nan 0.1000 0.0019
8 0.0186 nan 0.1000 0.0005
9 0.0169 nan 0.1000 0.0014
10 0.0154 nan 0.1000 0.0008
20 0.0081 nan 0.1000 0.0002
40 0.0030 nan 0.1000 0.0001
60 0.0017 nan 0.1000 -0.0001
80 0.0009 nan 0.1000 -0.0001
100 0.0005 nan 0.1000 -0.0000
120 0.0003 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold16: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold16: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0370 nan 0.1000 0.0054
2 0.0331 nan 0.1000 0.0032
3 0.0273 nan 0.1000 0.0066
4 0.0229 nan 0.1000 0.0028
5 0.0194 nan 0.1000 0.0034
6 0.0157 nan 0.1000 0.0027
7 0.0135 nan 0.1000 0.0020
8 0.0126 nan 0.1000 0.0001
9 0.0117 nan 0.1000 0.0002
10 0.0098 nan 0.1000 0.0013
20 0.0031 nan 0.1000 0.0003
40 0.0005 nan 0.1000 0.0000
60 0.0001 nan 0.1000 -0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 0.0000
140 0.0000 nan 0.1000 0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold16: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold16: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0370 nan 0.1000 0.0040
2 0.0324 nan 0.1000 0.0033
3 0.0270 nan 0.1000 0.0044
4 0.0243 nan 0.1000 0.0016
5 0.0219 nan 0.1000 0.0011
6 0.0189 nan 0.1000 0.0025
7 0.0179 nan 0.1000 0.0000
8 0.0163 nan 0.1000 -0.0000
9 0.0145 nan 0.1000 0.0002
10 0.0134 nan 0.1000 0.0005
20 0.0046 nan 0.1000 0.0003
40 0.0010 nan 0.1000 -0.0000
60 0.0004 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold16: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold16: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0385 nan 0.1000 0.0053
2 0.0350 nan 0.1000 0.0043
3 0.0319 nan 0.1000 0.0028
4 0.0295 nan 0.1000 0.0020
5 0.0261 nan 0.1000 0.0031
6 0.0238 nan 0.1000 0.0017
7 0.0224 nan 0.1000 0.0014
8 0.0202 nan 0.1000 0.0018
9 0.0179 nan 0.1000 0.0008
10 0.0165 nan 0.1000 0.0014
20 0.0089 nan 0.1000 -0.0001
40 0.0041 nan 0.1000 0.0002
60 0.0020 nan 0.1000 -0.0002
80 0.0011 nan 0.1000 -0.0000
100 0.0006 nan 0.1000 0.0000
120 0.0004 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold16: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold16: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0376 nan 0.1000 0.0058
2 0.0341 nan 0.1000 0.0003
3 0.0294 nan 0.1000 0.0033
4 0.0281 nan 0.1000 -0.0015
5 0.0227 nan 0.1000 0.0054
6 0.0203 nan 0.1000 0.0008
7 0.0179 nan 0.1000 0.0016
8 0.0152 nan 0.1000 0.0019
9 0.0128 nan 0.1000 0.0023
10 0.0122 nan 0.1000 0.0003
20 0.0043 nan 0.1000 0.0002
40 0.0006 nan 0.1000 0.0000
60 0.0001 nan 0.1000 0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold16: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold16: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0384 nan 0.1000 0.0022
2 0.0318 nan 0.1000 0.0050
3 0.0269 nan 0.1000 0.0022
4 0.0237 nan 0.1000 0.0023
5 0.0199 nan 0.1000 0.0032
6 0.0175 nan 0.1000 0.0013
7 0.0155 nan 0.1000 0.0020
8 0.0142 nan 0.1000 0.0002
9 0.0126 nan 0.1000 0.0006
10 0.0119 nan 0.1000 0.0000
20 0.0046 nan 0.1000 0.0002
40 0.0011 nan 0.1000 -0.0000
60 0.0003 nan 0.1000 0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 0.0000
160 0.0000 nan 0.1000 0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 0.0000
- Fold16: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold16: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0383 nan 0.1000 0.0060
2 0.0344 nan 0.1000 0.0023
3 0.0317 nan 0.1000 0.0024
4 0.0293 nan 0.1000 0.0020
5 0.0271 nan 0.1000 0.0002
6 0.0248 nan 0.1000 0.0015
7 0.0214 nan 0.1000 0.0020
8 0.0199 nan 0.1000 0.0007
9 0.0187 nan 0.1000 0.0015
10 0.0174 nan 0.1000 0.0002
20 0.0093 nan 0.1000 0.0004
40 0.0041 nan 0.1000 -0.0001
60 0.0025 nan 0.1000 0.0001
80 0.0016 nan 0.1000 -0.0002
100 0.0008 nan 0.1000 0.0000
120 0.0005 nan 0.1000 0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold16: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold17: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0434 nan 0.0100 0.0005
2 0.0428 nan 0.0100 0.0005
3 0.0421 nan 0.0100 0.0005
4 0.0415 nan 0.0100 0.0006
5 0.0412 nan 0.0100 0.0002
6 0.0407 nan 0.0100 0.0005
7 0.0405 nan 0.0100 -0.0000
8 0.0400 nan 0.0100 0.0005
9 0.0395 nan 0.0100 0.0002
10 0.0390 nan 0.0100 0.0006
20 0.0339 nan 0.0100 0.0001
40 0.0264 nan 0.0100 0.0002
60 0.0207 nan 0.0100 0.0002
80 0.0168 nan 0.0100 0.0001
100 0.0132 nan 0.0100 0.0002
120 0.0107 nan 0.0100 -0.0000
140 0.0089 nan 0.0100 -0.0000
160 0.0074 nan 0.0100 -0.0000
180 0.0062 nan 0.0100 0.0000
200 0.0052 nan 0.0100 0.0000
- Fold17: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold17: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0434 nan 0.0100 0.0004
2 0.0428 nan 0.0100 0.0006
3 0.0423 nan 0.0100 0.0005
4 0.0418 nan 0.0100 0.0006
5 0.0412 nan 0.0100 0.0006
6 0.0410 nan 0.0100 -0.0001
7 0.0405 nan 0.0100 0.0006
8 0.0399 nan 0.0100 0.0004
9 0.0395 nan 0.0100 0.0005
10 0.0389 nan 0.0100 0.0005
20 0.0343 nan 0.0100 0.0002
40 0.0274 nan 0.0100 0.0003
60 0.0220 nan 0.0100 0.0000
80 0.0177 nan 0.0100 0.0002
100 0.0148 nan 0.0100 0.0001
120 0.0121 nan 0.0100 -0.0000
140 0.0098 nan 0.0100 0.0000
160 0.0082 nan 0.0100 0.0000
180 0.0069 nan 0.0100 -0.0000
200 0.0059 nan 0.0100 0.0000
- Fold17: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold17: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0434 nan 0.0100 0.0006
2 0.0428 nan 0.0100 0.0006
3 0.0423 nan 0.0100 0.0004
4 0.0417 nan 0.0100 0.0005
5 0.0413 nan 0.0100 0.0005
6 0.0407 nan 0.0100 0.0005
7 0.0405 nan 0.0100 0.0001
8 0.0400 nan 0.0100 0.0003
9 0.0395 nan 0.0100 0.0005
10 0.0390 nan 0.0100 0.0005
20 0.0346 nan 0.0100 0.0004
40 0.0280 nan 0.0100 0.0001
60 0.0229 nan 0.0100 0.0001
80 0.0189 nan 0.0100 0.0001
100 0.0158 nan 0.0100 0.0001
120 0.0135 nan 0.0100 -0.0001
140 0.0120 nan 0.0100 0.0001
160 0.0105 nan 0.0100 0.0001
180 0.0092 nan 0.0100 -0.0000
200 0.0082 nan 0.0100 0.0000
- Fold17: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold17: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0436 nan 0.0100 0.0002
2 0.0428 nan 0.0100 0.0006
3 0.0421 nan 0.0100 0.0008
4 0.0413 nan 0.0100 0.0006
5 0.0408 nan 0.0100 0.0003
6 0.0401 nan 0.0100 0.0006
7 0.0395 nan 0.0100 0.0004
8 0.0391 nan 0.0100 0.0004
9 0.0386 nan 0.0100 0.0003
10 0.0382 nan 0.0100 0.0003
20 0.0325 nan 0.0100 0.0004
40 0.0246 nan 0.0100 0.0001
60 0.0190 nan 0.0100 0.0001
80 0.0143 nan 0.0100 0.0000
100 0.0109 nan 0.0100 0.0000
120 0.0086 nan 0.0100 0.0001
140 0.0069 nan 0.0100 0.0001
160 0.0055 nan 0.0100 -0.0000
180 0.0044 nan 0.0100 0.0000
200 0.0035 nan 0.0100 0.0000
- Fold17: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold17: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0435 nan 0.0100 0.0001
2 0.0428 nan 0.0100 0.0005
3 0.0424 nan 0.0100 0.0004
4 0.0416 nan 0.0100 0.0007
5 0.0410 nan 0.0100 0.0006
6 0.0403 nan 0.0100 0.0007
7 0.0399 nan 0.0100 0.0002
8 0.0394 nan 0.0100 0.0003
9 0.0387 nan 0.0100 0.0006
10 0.0381 nan 0.0100 0.0006
20 0.0328 nan 0.0100 0.0002
40 0.0254 nan 0.0100 0.0004
60 0.0195 nan 0.0100 0.0001
80 0.0151 nan 0.0100 0.0001
100 0.0119 nan 0.0100 0.0001
120 0.0098 nan 0.0100 0.0001
140 0.0079 nan 0.0100 0.0000
160 0.0063 nan 0.0100 0.0001
180 0.0051 nan 0.0100 0.0000
200 0.0042 nan 0.0100 0.0000
- Fold17: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold17: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0434 nan 0.0100 0.0006
2 0.0429 nan 0.0100 0.0003
3 0.0422 nan 0.0100 0.0006
4 0.0419 nan 0.0100 0.0002
5 0.0413 nan 0.0100 0.0004
6 0.0407 nan 0.0100 0.0006
7 0.0403 nan 0.0100 0.0003
8 0.0398 nan 0.0100 0.0004
9 0.0393 nan 0.0100 0.0005
10 0.0390 nan 0.0100 0.0000
20 0.0346 nan 0.0100 0.0004
40 0.0285 nan 0.0100 0.0001
60 0.0235 nan 0.0100 0.0002
80 0.0195 nan 0.0100 0.0002
100 0.0166 nan 0.0100 0.0001
120 0.0142 nan 0.0100 0.0001
140 0.0123 nan 0.0100 0.0001
160 0.0106 nan 0.0100 0.0000
180 0.0093 nan 0.0100 0.0000
200 0.0082 nan 0.0100 0.0000
- Fold17: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold17: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0432 nan 0.0100 0.0003
2 0.0424 nan 0.0100 0.0005
3 0.0420 nan 0.0100 0.0002
4 0.0413 nan 0.0100 0.0005
5 0.0407 nan 0.0100 0.0005
6 0.0402 nan 0.0100 0.0002
7 0.0397 nan 0.0100 0.0004
8 0.0390 nan 0.0100 0.0007
9 0.0385 nan 0.0100 0.0004
10 0.0382 nan 0.0100 0.0000
20 0.0334 nan 0.0100 0.0005
40 0.0251 nan 0.0100 0.0003
60 0.0187 nan 0.0100 0.0002
80 0.0139 nan 0.0100 0.0002
100 0.0105 nan 0.0100 0.0002
120 0.0082 nan 0.0100 0.0000
140 0.0064 nan 0.0100 0.0001
160 0.0049 nan 0.0100 0.0000
180 0.0038 nan 0.0100 0.0000
200 0.0030 nan 0.0100 0.0000
- Fold17: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold17: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0432 nan 0.0100 0.0004
2 0.0425 nan 0.0100 0.0007
3 0.0418 nan 0.0100 0.0006
4 0.0411 nan 0.0100 0.0002
5 0.0407 nan 0.0100 0.0003
6 0.0400 nan 0.0100 0.0004
7 0.0395 nan 0.0100 0.0003
8 0.0390 nan 0.0100 0.0006
9 0.0383 nan 0.0100 0.0006
10 0.0378 nan 0.0100 0.0005
20 0.0332 nan 0.0100 0.0000
40 0.0250 nan 0.0100 0.0004
60 0.0191 nan 0.0100 0.0003
80 0.0149 nan 0.0100 0.0001
100 0.0118 nan 0.0100 0.0001
120 0.0094 nan 0.0100 0.0001
140 0.0074 nan 0.0100 0.0001
160 0.0060 nan 0.0100 -0.0000
180 0.0049 nan 0.0100 0.0000
200 0.0041 nan 0.0100 0.0000
- Fold17: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold17: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0434 nan 0.0100 0.0005
2 0.0429 nan 0.0100 0.0004
3 0.0424 nan 0.0100 0.0005
4 0.0420 nan 0.0100 0.0002
5 0.0415 nan 0.0100 0.0005
6 0.0410 nan 0.0100 0.0003
7 0.0404 nan 0.0100 0.0005
8 0.0400 nan 0.0100 0.0003
9 0.0395 nan 0.0100 0.0005
10 0.0391 nan 0.0100 0.0003
20 0.0344 nan 0.0100 0.0005
40 0.0279 nan 0.0100 0.0001
60 0.0226 nan 0.0100 0.0001
80 0.0189 nan 0.0100 0.0002
100 0.0160 nan 0.0100 0.0001
120 0.0138 nan 0.0100 0.0001
140 0.0119 nan 0.0100 0.0000
160 0.0103 nan 0.0100 0.0001
180 0.0091 nan 0.0100 0.0000
200 0.0081 nan 0.0100 -0.0000
- Fold17: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold17: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0410 nan 0.0500 0.0026
2 0.0381 nan 0.0500 0.0018
3 0.0359 nan 0.0500 0.0021
4 0.0341 nan 0.0500 0.0017
5 0.0325 nan 0.0500 0.0019
6 0.0298 nan 0.0500 0.0016
7 0.0278 nan 0.0500 0.0018
8 0.0266 nan 0.0500 0.0013
9 0.0252 nan 0.0500 0.0003
10 0.0244 nan 0.0500 -0.0000
20 0.0151 nan 0.0500 0.0000
40 0.0064 nan 0.0500 0.0001
60 0.0035 nan 0.0500 0.0000
80 0.0018 nan 0.0500 0.0000
100 0.0010 nan 0.0500 -0.0000
120 0.0006 nan 0.0500 -0.0000
140 0.0004 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold17: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold17: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0406 nan 0.0500 0.0025
2 0.0378 nan 0.0500 0.0027
3 0.0351 nan 0.0500 0.0016
4 0.0326 nan 0.0500 0.0018
5 0.0310 nan 0.0500 0.0010
6 0.0289 nan 0.0500 0.0020
7 0.0269 nan 0.0500 0.0014
8 0.0250 nan 0.0500 0.0017
9 0.0233 nan 0.0500 0.0010
10 0.0215 nan 0.0500 0.0013
20 0.0135 nan 0.0500 0.0001
40 0.0064 nan 0.0500 -0.0000
60 0.0032 nan 0.0500 -0.0001
80 0.0019 nan 0.0500 0.0000
100 0.0012 nan 0.0500 -0.0000
120 0.0007 nan 0.0500 0.0000
140 0.0004 nan 0.0500 0.0000
160 0.0003 nan 0.0500 0.0000
180 0.0002 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold17: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold17: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0414 nan 0.0500 0.0015
2 0.0388 nan 0.0500 0.0013
3 0.0363 nan 0.0500 0.0024
4 0.0332 nan 0.0500 0.0022
5 0.0311 nan 0.0500 0.0017
6 0.0290 nan 0.0500 0.0019
7 0.0272 nan 0.0500 0.0018
8 0.0260 nan 0.0500 0.0014
9 0.0248 nan 0.0500 0.0010
10 0.0239 nan 0.0500 0.0005
20 0.0144 nan 0.0500 -0.0002
40 0.0078 nan 0.0500 0.0002
60 0.0047 nan 0.0500 -0.0000
80 0.0030 nan 0.0500 -0.0000
100 0.0022 nan 0.0500 -0.0001
120 0.0015 nan 0.0500 -0.0000
140 0.0011 nan 0.0500 -0.0000
160 0.0008 nan 0.0500 -0.0000
180 0.0006 nan 0.0500 -0.0000
200 0.0005 nan 0.0500 0.0000
- Fold17: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold17: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0407 nan 0.0500 0.0029
2 0.0374 nan 0.0500 0.0033
3 0.0348 nan 0.0500 0.0026
4 0.0325 nan 0.0500 0.0006
5 0.0297 nan 0.0500 0.0028
6 0.0277 nan 0.0500 0.0017
7 0.0263 nan 0.0500 0.0003
8 0.0246 nan 0.0500 0.0013
9 0.0225 nan 0.0500 0.0014
10 0.0209 nan 0.0500 0.0012
20 0.0115 nan 0.0500 0.0004
40 0.0033 nan 0.0500 0.0001
60 0.0013 nan 0.0500 -0.0000
80 0.0007 nan 0.0500 -0.0000
100 0.0003 nan 0.0500 -0.0000
120 0.0002 nan 0.0500 -0.0000
140 0.0001 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold17: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold17: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0407 nan 0.0500 0.0029
2 0.0380 nan 0.0500 0.0025
3 0.0355 nan 0.0500 0.0023
4 0.0335 nan 0.0500 0.0015
5 0.0315 nan 0.0500 0.0014
6 0.0288 nan 0.0500 0.0015
7 0.0264 nan 0.0500 0.0009
8 0.0249 nan 0.0500 0.0015
9 0.0235 nan 0.0500 0.0016
10 0.0217 nan 0.0500 0.0011
20 0.0114 nan 0.0500 0.0004
40 0.0042 nan 0.0500 0.0001
60 0.0019 nan 0.0500 -0.0000
80 0.0009 nan 0.0500 0.0000
100 0.0004 nan 0.0500 -0.0000
120 0.0002 nan 0.0500 0.0000
140 0.0001 nan 0.0500 -0.0000
160 0.0001 nan 0.0500 0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold17: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold17: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0421 nan 0.0500 0.0007
2 0.0400 nan 0.0500 0.0019
3 0.0379 nan 0.0500 0.0015
4 0.0349 nan 0.0500 0.0013
5 0.0338 nan 0.0500 0.0004
6 0.0317 nan 0.0500 0.0010
7 0.0300 nan 0.0500 0.0020
8 0.0283 nan 0.0500 0.0014
9 0.0269 nan 0.0500 0.0016
10 0.0262 nan 0.0500 0.0003
20 0.0166 nan 0.0500 0.0007
40 0.0079 nan 0.0500 0.0002
60 0.0046 nan 0.0500 0.0001
80 0.0030 nan 0.0500 0.0001
100 0.0021 nan 0.0500 -0.0000
120 0.0015 nan 0.0500 -0.0000
140 0.0011 nan 0.0500 0.0000
160 0.0008 nan 0.0500 -0.0000
180 0.0006 nan 0.0500 0.0000
200 0.0005 nan 0.0500 -0.0000
- Fold17: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold17: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0404 nan 0.0500 0.0025
2 0.0378 nan 0.0500 0.0024
3 0.0341 nan 0.0500 0.0019
4 0.0322 nan 0.0500 0.0021
5 0.0295 nan 0.0500 0.0014
6 0.0277 nan 0.0500 -0.0001
7 0.0250 nan 0.0500 0.0018
8 0.0242 nan 0.0500 0.0007
9 0.0226 nan 0.0500 0.0006
10 0.0210 nan 0.0500 0.0020
20 0.0114 nan 0.0500 0.0002
40 0.0031 nan 0.0500 0.0001
60 0.0011 nan 0.0500 0.0000
80 0.0005 nan 0.0500 0.0000
100 0.0002 nan 0.0500 0.0000
120 0.0001 nan 0.0500 0.0000
140 0.0000 nan 0.0500 0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold17: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold17: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0403 nan 0.0500 0.0031
2 0.0374 nan 0.0500 0.0022
3 0.0337 nan 0.0500 0.0021
4 0.0314 nan 0.0500 0.0018
5 0.0302 nan 0.0500 0.0011
6 0.0284 nan 0.0500 0.0021
7 0.0269 nan 0.0500 0.0009
8 0.0242 nan 0.0500 0.0018
9 0.0222 nan 0.0500 0.0016
10 0.0201 nan 0.0500 0.0013
20 0.0095 nan 0.0500 -0.0003
40 0.0031 nan 0.0500 0.0002
60 0.0013 nan 0.0500 0.0000
80 0.0006 nan 0.0500 0.0000
100 0.0003 nan 0.0500 -0.0000
120 0.0002 nan 0.0500 -0.0000
140 0.0001 nan 0.0500 -0.0000
160 0.0001 nan 0.0500 0.0000
180 0.0001 nan 0.0500 0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold17: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold17: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0414 nan 0.0500 0.0022
2 0.0383 nan 0.0500 0.0027
3 0.0363 nan 0.0500 0.0023
4 0.0349 nan 0.0500 0.0013
5 0.0330 nan 0.0500 0.0016
6 0.0317 nan 0.0500 0.0004
7 0.0297 nan 0.0500 0.0012
8 0.0282 nan 0.0500 0.0012
9 0.0269 nan 0.0500 0.0009
10 0.0250 nan 0.0500 0.0015
20 0.0157 nan 0.0500 0.0005
40 0.0079 nan 0.0500 0.0001
60 0.0049 nan 0.0500 -0.0002
80 0.0032 nan 0.0500 0.0001
100 0.0022 nan 0.0500 -0.0000
120 0.0014 nan 0.0500 -0.0000
140 0.0010 nan 0.0500 0.0000
160 0.0007 nan 0.0500 0.0000
180 0.0005 nan 0.0500 0.0000
200 0.0004 nan 0.0500 -0.0000
- Fold17: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold17: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0381 nan 0.1000 0.0067
2 0.0332 nan 0.1000 0.0049
3 0.0301 nan 0.1000 0.0020
4 0.0270 nan 0.1000 0.0028
5 0.0239 nan 0.1000 0.0030
6 0.0218 nan 0.1000 0.0015
7 0.0189 nan 0.1000 0.0018
8 0.0165 nan 0.1000 0.0017
9 0.0152 nan 0.1000 0.0012
10 0.0146 nan 0.1000 -0.0004
20 0.0063 nan 0.1000 0.0006
40 0.0017 nan 0.1000 -0.0000
60 0.0007 nan 0.1000 -0.0000
80 0.0003 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold17: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold17: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0390 nan 0.1000 0.0047
2 0.0339 nan 0.1000 0.0038
3 0.0314 nan 0.1000 0.0011
4 0.0284 nan 0.1000 0.0037
5 0.0258 nan 0.1000 0.0024
6 0.0227 nan 0.1000 0.0027
7 0.0196 nan 0.1000 0.0022
8 0.0174 nan 0.1000 0.0016
9 0.0153 nan 0.1000 0.0020
10 0.0144 nan 0.1000 -0.0002
20 0.0064 nan 0.1000 0.0002
40 0.0022 nan 0.1000 -0.0000
60 0.0009 nan 0.1000 -0.0000
80 0.0004 nan 0.1000 -0.0000
100 0.0002 nan 0.1000 0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold17: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold17: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0401 nan 0.1000 0.0017
2 0.0364 nan 0.1000 0.0023
3 0.0316 nan 0.1000 0.0040
4 0.0279 nan 0.1000 0.0021
5 0.0255 nan 0.1000 -0.0008
6 0.0230 nan 0.1000 0.0028
7 0.0199 nan 0.1000 0.0024
8 0.0178 nan 0.1000 0.0014
9 0.0169 nan 0.1000 0.0007
10 0.0156 nan 0.1000 -0.0010
20 0.0067 nan 0.1000 0.0004
40 0.0026 nan 0.1000 -0.0001
60 0.0010 nan 0.1000 0.0000
80 0.0005 nan 0.1000 -0.0000
100 0.0003 nan 0.1000 0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 0.0000
- Fold17: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold17: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0381 nan 0.1000 0.0058
2 0.0318 nan 0.1000 0.0066
3 0.0291 nan 0.1000 0.0025
4 0.0250 nan 0.1000 0.0027
5 0.0209 nan 0.1000 0.0022
6 0.0189 nan 0.1000 0.0007
7 0.0155 nan 0.1000 0.0017
8 0.0134 nan 0.1000 0.0013
9 0.0117 nan 0.1000 0.0013
10 0.0098 nan 0.1000 0.0010
20 0.0033 nan 0.1000 0.0003
40 0.0005 nan 0.1000 -0.0000
60 0.0001 nan 0.1000 -0.0000
80 0.0000 nan 0.1000 0.0000
100 0.0000 nan 0.1000 0.0000
120 0.0000 nan 0.1000 0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold17: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold17: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0377 nan 0.1000 0.0061
2 0.0322 nan 0.1000 0.0043
3 0.0281 nan 0.1000 0.0044
4 0.0240 nan 0.1000 0.0040
5 0.0207 nan 0.1000 0.0025
6 0.0178 nan 0.1000 0.0025
7 0.0158 nan 0.1000 0.0015
8 0.0130 nan 0.1000 0.0014
9 0.0116 nan 0.1000 0.0005
10 0.0106 nan 0.1000 0.0011
20 0.0040 nan 0.1000 0.0001
40 0.0008 nan 0.1000 -0.0000
60 0.0003 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold17: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold17: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0369 nan 0.1000 0.0054
2 0.0317 nan 0.1000 0.0040
3 0.0286 nan 0.1000 0.0030
4 0.0253 nan 0.1000 0.0017
5 0.0227 nan 0.1000 0.0025
6 0.0203 nan 0.1000 0.0013
7 0.0181 nan 0.1000 0.0018
8 0.0162 nan 0.1000 0.0017
9 0.0150 nan 0.1000 0.0008
10 0.0142 nan 0.1000 0.0006
20 0.0071 nan 0.1000 0.0005
40 0.0029 nan 0.1000 -0.0001
60 0.0012 nan 0.1000 0.0001
80 0.0006 nan 0.1000 -0.0000
100 0.0003 nan 0.1000 -0.0000
120 0.0002 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold17: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold17: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0362 nan 0.1000 0.0056
2 0.0302 nan 0.1000 0.0042
3 0.0276 nan 0.1000 -0.0002
4 0.0247 nan 0.1000 0.0002
5 0.0223 nan 0.1000 0.0019
6 0.0192 nan 0.1000 0.0023
7 0.0177 nan 0.1000 -0.0004
8 0.0149 nan 0.1000 0.0024
9 0.0136 nan 0.1000 0.0004
10 0.0115 nan 0.1000 0.0019
20 0.0026 nan 0.1000 0.0003
40 0.0005 nan 0.1000 0.0000
60 0.0001 nan 0.1000 0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold17: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold17: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0392 nan 0.1000 0.0046
2 0.0351 nan 0.1000 0.0028
3 0.0309 nan 0.1000 0.0028
4 0.0281 nan 0.1000 0.0036
5 0.0246 nan 0.1000 0.0026
6 0.0220 nan 0.1000 0.0014
7 0.0212 nan 0.1000 0.0000
8 0.0185 nan 0.1000 0.0012
9 0.0157 nan 0.1000 0.0018
10 0.0131 nan 0.1000 0.0004
20 0.0056 nan 0.1000 -0.0000
40 0.0017 nan 0.1000 0.0001
60 0.0004 nan 0.1000 -0.0000
80 0.0002 nan 0.1000 0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 0.0000
- Fold17: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold17: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0412 nan 0.1000 0.0017
2 0.0354 nan 0.1000 0.0039
3 0.0326 nan 0.1000 0.0012
4 0.0289 nan 0.1000 0.0016
5 0.0266 nan 0.1000 0.0029
6 0.0243 nan 0.1000 -0.0005
7 0.0234 nan 0.1000 -0.0007
8 0.0222 nan 0.1000 0.0005
9 0.0199 nan 0.1000 0.0017
10 0.0177 nan 0.1000 0.0004
20 0.0086 nan 0.1000 0.0007
40 0.0030 nan 0.1000 -0.0002
60 0.0016 nan 0.1000 -0.0001
80 0.0009 nan 0.1000 0.0000
100 0.0005 nan 0.1000 -0.0000
120 0.0002 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 0.0000
- Fold17: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold18: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0426 nan 0.0100 0.0007
2 0.0422 nan 0.0100 0.0004
3 0.0415 nan 0.0100 0.0005
4 0.0412 nan 0.0100 0.0000
5 0.0408 nan 0.0100 0.0005
6 0.0403 nan 0.0100 0.0005
7 0.0399 nan 0.0100 0.0001
8 0.0393 nan 0.0100 0.0004
9 0.0388 nan 0.0100 0.0003
10 0.0384 nan 0.0100 0.0003
20 0.0342 nan 0.0100 0.0004
40 0.0270 nan 0.0100 0.0002
60 0.0218 nan 0.0100 0.0000
80 0.0175 nan 0.0100 0.0002
100 0.0142 nan 0.0100 0.0001
120 0.0117 nan 0.0100 0.0001
140 0.0095 nan 0.0100 0.0001
160 0.0079 nan 0.0100 0.0000
180 0.0068 nan 0.0100 0.0000
200 0.0059 nan 0.0100 0.0000
- Fold18: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold18: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0428 nan 0.0100 0.0003
2 0.0424 nan 0.0100 0.0004
3 0.0418 nan 0.0100 0.0005
4 0.0412 nan 0.0100 0.0003
5 0.0406 nan 0.0100 0.0005
6 0.0402 nan 0.0100 0.0005
7 0.0398 nan 0.0100 0.0003
8 0.0393 nan 0.0100 0.0004
9 0.0388 nan 0.0100 0.0004
10 0.0382 nan 0.0100 0.0005
20 0.0345 nan 0.0100 0.0003
40 0.0274 nan 0.0100 0.0001
60 0.0225 nan 0.0100 0.0002
80 0.0184 nan 0.0100 0.0001
100 0.0151 nan 0.0100 0.0002
120 0.0126 nan 0.0100 0.0000
140 0.0102 nan 0.0100 0.0001
160 0.0087 nan 0.0100 0.0000
180 0.0073 nan 0.0100 -0.0000
200 0.0061 nan 0.0100 0.0000
- Fold18: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold18: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0430 nan 0.0100 0.0001
2 0.0424 nan 0.0100 0.0006
3 0.0418 nan 0.0100 0.0004
4 0.0415 nan 0.0100 0.0004
5 0.0410 nan 0.0100 0.0002
6 0.0404 nan 0.0100 0.0004
7 0.0404 nan 0.0100 -0.0004
8 0.0402 nan 0.0100 0.0001
9 0.0397 nan 0.0100 0.0005
10 0.0392 nan 0.0100 0.0005
20 0.0348 nan 0.0100 0.0004
40 0.0280 nan 0.0100 -0.0001
60 0.0230 nan 0.0100 0.0000
80 0.0189 nan 0.0100 0.0002
100 0.0158 nan 0.0100 0.0001
120 0.0134 nan 0.0100 0.0001
140 0.0116 nan 0.0100 0.0000
160 0.0101 nan 0.0100 0.0001
180 0.0091 nan 0.0100 0.0000
200 0.0084 nan 0.0100 -0.0001
- Fold18: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold18: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0427 nan 0.0100 0.0005
2 0.0421 nan 0.0100 0.0004
3 0.0417 nan 0.0100 0.0001
4 0.0412 nan 0.0100 0.0003
5 0.0406 nan 0.0100 0.0004
6 0.0400 nan 0.0100 0.0004
7 0.0392 nan 0.0100 0.0008
8 0.0387 nan 0.0100 0.0002
9 0.0381 nan 0.0100 0.0005
10 0.0377 nan 0.0100 0.0003
20 0.0324 nan 0.0100 0.0002
40 0.0255 nan 0.0100 0.0002
60 0.0197 nan 0.0100 0.0003
80 0.0158 nan 0.0100 0.0001
100 0.0121 nan 0.0100 0.0001
120 0.0098 nan 0.0100 0.0000
140 0.0079 nan 0.0100 0.0001
160 0.0065 nan 0.0100 0.0000
180 0.0052 nan 0.0100 0.0001
200 0.0042 nan 0.0100 0.0000
- Fold18: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold18: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0428 nan 0.0100 0.0004
2 0.0422 nan 0.0100 0.0005
3 0.0415 nan 0.0100 0.0005
4 0.0409 nan 0.0100 0.0005
5 0.0402 nan 0.0100 0.0005
6 0.0395 nan 0.0100 0.0005
7 0.0390 nan 0.0100 0.0005
8 0.0386 nan 0.0100 0.0004
9 0.0381 nan 0.0100 0.0001
10 0.0377 nan 0.0100 0.0004
20 0.0322 nan 0.0100 0.0005
40 0.0246 nan 0.0100 0.0003
60 0.0186 nan 0.0100 0.0002
80 0.0147 nan 0.0100 0.0002
100 0.0113 nan 0.0100 0.0001
120 0.0089 nan 0.0100 0.0001
140 0.0071 nan 0.0100 0.0001
160 0.0057 nan 0.0100 0.0000
180 0.0048 nan 0.0100 0.0000
200 0.0040 nan 0.0100 0.0000
- Fold18: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold18: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0427 nan 0.0100 0.0006
2 0.0423 nan 0.0100 0.0004
3 0.0418 nan 0.0100 0.0005
4 0.0412 nan 0.0100 0.0004
5 0.0408 nan 0.0100 0.0004
6 0.0407 nan 0.0100 -0.0002
7 0.0403 nan 0.0100 0.0003
8 0.0399 nan 0.0100 0.0003
9 0.0395 nan 0.0100 0.0003
10 0.0390 nan 0.0100 0.0005
20 0.0349 nan 0.0100 0.0005
40 0.0279 nan 0.0100 0.0003
60 0.0232 nan 0.0100 0.0000
80 0.0196 nan 0.0100 -0.0000
100 0.0164 nan 0.0100 0.0001
120 0.0140 nan 0.0100 0.0001
140 0.0123 nan 0.0100 0.0000
160 0.0107 nan 0.0100 -0.0000
180 0.0097 nan 0.0100 -0.0001
200 0.0087 nan 0.0100 0.0000
- Fold18: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold18: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0428 nan 0.0100 0.0002
2 0.0422 nan 0.0100 0.0002
3 0.0417 nan 0.0100 0.0004
4 0.0411 nan 0.0100 0.0002
5 0.0404 nan 0.0100 0.0005
6 0.0398 nan 0.0100 0.0004
7 0.0392 nan 0.0100 0.0004
8 0.0386 nan 0.0100 0.0005
9 0.0381 nan 0.0100 0.0002
10 0.0375 nan 0.0100 0.0004
20 0.0322 nan 0.0100 0.0004
40 0.0238 nan 0.0100 0.0001
60 0.0178 nan 0.0100 0.0000
80 0.0133 nan 0.0100 0.0002
100 0.0103 nan 0.0100 0.0002
120 0.0081 nan 0.0100 0.0001
140 0.0063 nan 0.0100 0.0000
160 0.0051 nan 0.0100 0.0000
180 0.0040 nan 0.0100 0.0000
200 0.0032 nan 0.0100 0.0000
- Fold18: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold18: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0429 nan 0.0100 0.0004
2 0.0423 nan 0.0100 0.0002
3 0.0418 nan 0.0100 0.0003
4 0.0413 nan 0.0100 0.0003
5 0.0406 nan 0.0100 0.0007
6 0.0399 nan 0.0100 0.0006
7 0.0395 nan 0.0100 0.0004
8 0.0390 nan 0.0100 0.0006
9 0.0383 nan 0.0100 0.0004
10 0.0377 nan 0.0100 0.0006
20 0.0326 nan 0.0100 0.0004
40 0.0249 nan 0.0100 0.0002
60 0.0200 nan 0.0100 0.0002
80 0.0151 nan 0.0100 0.0001
100 0.0119 nan 0.0100 0.0001
120 0.0096 nan 0.0100 0.0001
140 0.0076 nan 0.0100 0.0000
160 0.0061 nan 0.0100 -0.0000
180 0.0050 nan 0.0100 0.0000
200 0.0041 nan 0.0100 -0.0000
- Fold18: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold18: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0430 nan 0.0100 0.0004
2 0.0425 nan 0.0100 0.0005
3 0.0420 nan 0.0100 0.0003
4 0.0416 nan 0.0100 0.0004
5 0.0410 nan 0.0100 0.0006
6 0.0404 nan 0.0100 0.0006
7 0.0398 nan 0.0100 0.0005
8 0.0393 nan 0.0100 0.0005
9 0.0387 nan 0.0100 0.0005
10 0.0382 nan 0.0100 0.0001
20 0.0348 nan 0.0100 0.0001
40 0.0285 nan 0.0100 0.0003
60 0.0233 nan 0.0100 0.0002
80 0.0194 nan 0.0100 0.0001
100 0.0164 nan 0.0100 -0.0000
120 0.0136 nan 0.0100 0.0001
140 0.0116 nan 0.0100 0.0000
160 0.0102 nan 0.0100 0.0000
180 0.0090 nan 0.0100 0.0000
200 0.0080 nan 0.0100 0.0000
- Fold18: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold18: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0408 nan 0.0500 0.0028
2 0.0380 nan 0.0500 0.0008
3 0.0367 nan 0.0500 0.0002
4 0.0343 nan 0.0500 0.0016
5 0.0327 nan 0.0500 0.0015
6 0.0302 nan 0.0500 0.0016
7 0.0285 nan 0.0500 0.0017
8 0.0268 nan 0.0500 0.0012
9 0.0247 nan 0.0500 0.0018
10 0.0240 nan 0.0500 0.0006
20 0.0135 nan 0.0500 0.0007
40 0.0055 nan 0.0500 0.0002
60 0.0027 nan 0.0500 0.0001
80 0.0014 nan 0.0500 0.0000
100 0.0008 nan 0.0500 0.0000
120 0.0005 nan 0.0500 0.0000
140 0.0003 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 0.0000
- Fold18: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold18: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0413 nan 0.0500 0.0013
2 0.0394 nan 0.0500 0.0016
3 0.0379 nan 0.0500 0.0003
4 0.0360 nan 0.0500 0.0012
5 0.0336 nan 0.0500 0.0024
6 0.0310 nan 0.0500 0.0019
7 0.0291 nan 0.0500 0.0011
8 0.0277 nan 0.0500 0.0006
9 0.0260 nan 0.0500 0.0015
10 0.0249 nan 0.0500 0.0009
20 0.0144 nan 0.0500 0.0008
40 0.0061 nan 0.0500 0.0001
60 0.0034 nan 0.0500 -0.0000
80 0.0022 nan 0.0500 0.0000
100 0.0014 nan 0.0500 -0.0001
120 0.0009 nan 0.0500 -0.0000
140 0.0006 nan 0.0500 -0.0000
160 0.0004 nan 0.0500 -0.0000
180 0.0002 nan 0.0500 0.0000
200 0.0002 nan 0.0500 -0.0000
- Fold18: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold18: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0408 nan 0.0500 0.0026
2 0.0378 nan 0.0500 0.0026
3 0.0359 nan 0.0500 0.0012
4 0.0334 nan 0.0500 0.0018
5 0.0323 nan 0.0500 0.0005
6 0.0309 nan 0.0500 0.0011
7 0.0292 nan 0.0500 0.0017
8 0.0282 nan 0.0500 0.0007
9 0.0267 nan 0.0500 0.0016
10 0.0252 nan 0.0500 0.0007
20 0.0169 nan 0.0500 0.0002
40 0.0096 nan 0.0500 -0.0001
60 0.0067 nan 0.0500 0.0001
80 0.0045 nan 0.0500 0.0001
100 0.0034 nan 0.0500 -0.0000
120 0.0022 nan 0.0500 0.0000
140 0.0015 nan 0.0500 0.0000
160 0.0010 nan 0.0500 -0.0000
180 0.0008 nan 0.0500 -0.0000
200 0.0006 nan 0.0500 -0.0000
- Fold18: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold18: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0417 nan 0.0500 0.0007
2 0.0404 nan 0.0500 0.0013
3 0.0375 nan 0.0500 0.0027
4 0.0343 nan 0.0500 0.0026
5 0.0309 nan 0.0500 0.0030
6 0.0286 nan 0.0500 0.0017
7 0.0261 nan 0.0500 0.0020
8 0.0245 nan 0.0500 0.0019
9 0.0228 nan 0.0500 0.0013
10 0.0212 nan 0.0500 0.0019
20 0.0119 nan 0.0500 0.0003
40 0.0038 nan 0.0500 0.0001
60 0.0015 nan 0.0500 -0.0000
80 0.0007 nan 0.0500 -0.0000
100 0.0003 nan 0.0500 0.0000
120 0.0001 nan 0.0500 0.0000
140 0.0001 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold18: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold18: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0397 nan 0.0500 0.0031
2 0.0366 nan 0.0500 0.0028
3 0.0341 nan 0.0500 0.0021
4 0.0317 nan 0.0500 0.0020
5 0.0297 nan 0.0500 0.0020
6 0.0274 nan 0.0500 0.0015
7 0.0253 nan 0.0500 0.0014
8 0.0236 nan 0.0500 0.0004
9 0.0227 nan 0.0500 0.0000
10 0.0217 nan 0.0500 0.0007
20 0.0128 nan 0.0500 0.0001
40 0.0050 nan 0.0500 0.0002
60 0.0022 nan 0.0500 -0.0000
80 0.0010 nan 0.0500 0.0000
100 0.0006 nan 0.0500 -0.0000
120 0.0004 nan 0.0500 -0.0000
140 0.0002 nan 0.0500 -0.0000
160 0.0001 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold18: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold18: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0405 nan 0.0500 0.0011
2 0.0389 nan 0.0500 0.0016
3 0.0360 nan 0.0500 0.0020
4 0.0339 nan 0.0500 0.0008
5 0.0315 nan 0.0500 0.0020
6 0.0302 nan 0.0500 -0.0005
7 0.0289 nan 0.0500 0.0011
8 0.0271 nan 0.0500 0.0016
9 0.0261 nan 0.0500 0.0008
10 0.0250 nan 0.0500 0.0008
20 0.0153 nan 0.0500 0.0006
40 0.0082 nan 0.0500 0.0000
60 0.0053 nan 0.0500 -0.0001
80 0.0034 nan 0.0500 -0.0000
100 0.0022 nan 0.0500 0.0000
120 0.0015 nan 0.0500 0.0000
140 0.0010 nan 0.0500 0.0000
160 0.0008 nan 0.0500 -0.0000
180 0.0006 nan 0.0500 -0.0000
200 0.0004 nan 0.0500 -0.0000
- Fold18: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold18: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0398 nan 0.0500 0.0007
2 0.0389 nan 0.0500 0.0002
3 0.0365 nan 0.0500 0.0022
4 0.0335 nan 0.0500 0.0023
5 0.0309 nan 0.0500 0.0014
6 0.0295 nan 0.0500 0.0013
7 0.0269 nan 0.0500 0.0020
8 0.0248 nan 0.0500 0.0020
9 0.0235 nan 0.0500 0.0011
10 0.0218 nan 0.0500 0.0005
20 0.0102 nan 0.0500 0.0007
40 0.0028 nan 0.0500 0.0001
60 0.0010 nan 0.0500 0.0000
80 0.0004 nan 0.0500 -0.0000
100 0.0002 nan 0.0500 0.0000
120 0.0001 nan 0.0500 0.0000
140 0.0000 nan 0.0500 0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold18: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold18: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0403 nan 0.0500 0.0016
2 0.0385 nan 0.0500 0.0010
3 0.0358 nan 0.0500 0.0021
4 0.0326 nan 0.0500 0.0014
5 0.0302 nan 0.0500 0.0013
6 0.0279 nan 0.0500 0.0020
7 0.0258 nan 0.0500 0.0016
8 0.0239 nan 0.0500 0.0012
9 0.0224 nan 0.0500 0.0010
10 0.0205 nan 0.0500 0.0017
20 0.0113 nan 0.0500 0.0003
40 0.0044 nan 0.0500 0.0001
60 0.0021 nan 0.0500 -0.0000
80 0.0014 nan 0.0500 -0.0000
100 0.0009 nan 0.0500 0.0000
120 0.0006 nan 0.0500 -0.0000
140 0.0005 nan 0.0500 -0.0000
160 0.0003 nan 0.0500 -0.0000
180 0.0002 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 0.0000
- Fold18: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold18: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0405 nan 0.0500 0.0025
2 0.0377 nan 0.0500 0.0023
3 0.0370 nan 0.0500 -0.0008
4 0.0348 nan 0.0500 0.0023
5 0.0327 nan 0.0500 0.0021
6 0.0306 nan 0.0500 0.0017
7 0.0296 nan 0.0500 0.0004
8 0.0275 nan 0.0500 0.0012
9 0.0259 nan 0.0500 0.0013
10 0.0247 nan 0.0500 0.0010
20 0.0153 nan 0.0500 0.0007
40 0.0088 nan 0.0500 -0.0000
60 0.0051 nan 0.0500 0.0001
80 0.0036 nan 0.0500 0.0000
100 0.0026 nan 0.0500 0.0000
120 0.0019 nan 0.0500 -0.0001
140 0.0013 nan 0.0500 -0.0000
160 0.0009 nan 0.0500 -0.0000
180 0.0006 nan 0.0500 0.0000
200 0.0005 nan 0.0500 -0.0000
- Fold18: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold18: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0379 nan 0.1000 0.0043
2 0.0335 nan 0.1000 0.0034
3 0.0301 nan 0.1000 0.0034
4 0.0275 nan 0.1000 0.0026
5 0.0236 nan 0.1000 0.0027
6 0.0204 nan 0.1000 0.0027
7 0.0180 nan 0.1000 0.0019
8 0.0171 nan 0.1000 0.0001
9 0.0152 nan 0.1000 0.0017
10 0.0139 nan 0.1000 0.0013
20 0.0059 nan 0.1000 0.0003
40 0.0020 nan 0.1000 -0.0001
60 0.0008 nan 0.1000 -0.0000
80 0.0003 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 0.0000
120 0.0001 nan 0.1000 0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold18: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold18: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0409 nan 0.1000 0.0017
2 0.0377 nan 0.1000 0.0026
3 0.0321 nan 0.1000 0.0045
4 0.0271 nan 0.1000 0.0048
5 0.0248 nan 0.1000 0.0021
6 0.0209 nan 0.1000 0.0018
7 0.0189 nan 0.1000 0.0005
8 0.0172 nan 0.1000 0.0004
9 0.0152 nan 0.1000 0.0016
10 0.0137 nan 0.1000 0.0013
20 0.0065 nan 0.1000 0.0005
40 0.0023 nan 0.1000 -0.0001
60 0.0008 nan 0.1000 -0.0000
80 0.0003 nan 0.1000 -0.0000
100 0.0002 nan 0.1000 -0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold18: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold18: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0413 nan 0.1000 -0.0001
2 0.0366 nan 0.1000 0.0046
3 0.0344 nan 0.1000 0.0014
4 0.0298 nan 0.1000 0.0041
5 0.0265 nan 0.1000 0.0028
6 0.0235 nan 0.1000 0.0026
7 0.0215 nan 0.1000 0.0016
8 0.0200 nan 0.1000 0.0015
9 0.0180 nan 0.1000 0.0019
10 0.0171 nan 0.1000 0.0006
20 0.0085 nan 0.1000 -0.0000
40 0.0033 nan 0.1000 0.0001
60 0.0017 nan 0.1000 0.0000
80 0.0010 nan 0.1000 -0.0000
100 0.0006 nan 0.1000 -0.0000
120 0.0004 nan 0.1000 -0.0000
140 0.0003 nan 0.1000 0.0000
160 0.0002 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold18: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold18: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0385 nan 0.1000 0.0039
2 0.0343 nan 0.1000 0.0028
3 0.0315 nan 0.1000 0.0027
4 0.0266 nan 0.1000 0.0034
5 0.0231 nan 0.1000 0.0038
6 0.0199 nan 0.1000 0.0023
7 0.0166 nan 0.1000 0.0015
8 0.0138 nan 0.1000 0.0015
9 0.0117 nan 0.1000 0.0022
10 0.0101 nan 0.1000 0.0014
20 0.0030 nan 0.1000 0.0001
40 0.0006 nan 0.1000 -0.0000
60 0.0002 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold18: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold18: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0371 nan 0.1000 0.0034
2 0.0333 nan 0.1000 0.0031
3 0.0289 nan 0.1000 0.0034
4 0.0248 nan 0.1000 0.0035
5 0.0237 nan 0.1000 -0.0001
6 0.0209 nan 0.1000 0.0010
7 0.0182 nan 0.1000 0.0018
8 0.0165 nan 0.1000 0.0008
9 0.0144 nan 0.1000 0.0016
10 0.0127 nan 0.1000 0.0008
20 0.0050 nan 0.1000 0.0002
40 0.0009 nan 0.1000 -0.0001
60 0.0003 nan 0.1000 0.0000
80 0.0001 nan 0.1000 0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 0.0000
160 0.0000 nan 0.1000 0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold18: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold18: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0385 nan 0.1000 0.0045
2 0.0342 nan 0.1000 0.0029
3 0.0299 nan 0.1000 0.0014
4 0.0267 nan 0.1000 0.0018
5 0.0238 nan 0.1000 0.0030
6 0.0217 nan 0.1000 0.0004
7 0.0197 nan 0.1000 -0.0001
8 0.0170 nan 0.1000 0.0018
9 0.0162 nan 0.1000 -0.0002
10 0.0157 nan 0.1000 0.0001
20 0.0090 nan 0.1000 0.0000
40 0.0041 nan 0.1000 -0.0002
60 0.0020 nan 0.1000 -0.0000
80 0.0011 nan 0.1000 -0.0000
100 0.0007 nan 0.1000 0.0000
120 0.0005 nan 0.1000 0.0000
140 0.0003 nan 0.1000 -0.0000
160 0.0002 nan 0.1000 0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold18: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold18: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0370 nan 0.1000 0.0047
2 0.0318 nan 0.1000 0.0037
3 0.0262 nan 0.1000 0.0036
4 0.0215 nan 0.1000 0.0036
5 0.0185 nan 0.1000 0.0004
6 0.0162 nan 0.1000 0.0020
7 0.0135 nan 0.1000 0.0017
8 0.0111 nan 0.1000 0.0021
9 0.0092 nan 0.1000 0.0008
10 0.0084 nan 0.1000 0.0005
20 0.0028 nan 0.1000 -0.0000
40 0.0007 nan 0.1000 -0.0000
60 0.0002 nan 0.1000 0.0000
80 0.0000 nan 0.1000 0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold18: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold18: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0381 nan 0.1000 0.0047
2 0.0340 nan 0.1000 0.0045
3 0.0286 nan 0.1000 0.0019
4 0.0251 nan 0.1000 0.0032
5 0.0228 nan 0.1000 0.0018
6 0.0210 nan 0.1000 0.0010
7 0.0183 nan 0.1000 0.0025
8 0.0161 nan 0.1000 0.0017
9 0.0143 nan 0.1000 0.0017
10 0.0127 nan 0.1000 0.0008
20 0.0045 nan 0.1000 0.0004
40 0.0009 nan 0.1000 -0.0000
60 0.0003 nan 0.1000 0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 0.0000
- Fold18: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold18: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0376 nan 0.1000 0.0057
2 0.0320 nan 0.1000 0.0033
3 0.0283 nan 0.1000 0.0037
4 0.0255 nan 0.1000 0.0029
5 0.0232 nan 0.1000 0.0001
6 0.0212 nan 0.1000 0.0016
7 0.0201 nan 0.1000 -0.0003
8 0.0181 nan 0.1000 0.0000
9 0.0162 nan 0.1000 0.0011
10 0.0156 nan 0.1000 -0.0000
20 0.0099 nan 0.1000 0.0002
40 0.0039 nan 0.1000 0.0000
60 0.0021 nan 0.1000 -0.0000
80 0.0015 nan 0.1000 -0.0000
100 0.0010 nan 0.1000 -0.0000
120 0.0006 nan 0.1000 -0.0000
140 0.0004 nan 0.1000 -0.0000
160 0.0003 nan 0.1000 -0.0000
180 0.0002 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold18: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold19: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0429 nan 0.0100 -0.0002
2 0.0424 nan 0.0100 0.0006
3 0.0417 nan 0.0100 0.0005
4 0.0412 nan 0.0100 0.0005
5 0.0408 nan 0.0100 0.0002
6 0.0402 nan 0.0100 0.0005
7 0.0397 nan 0.0100 0.0006
8 0.0392 nan 0.0100 0.0000
9 0.0386 nan 0.0100 0.0003
10 0.0383 nan 0.0100 0.0002
20 0.0339 nan 0.0100 0.0001
40 0.0270 nan 0.0100 0.0003
60 0.0226 nan 0.0100 -0.0000
80 0.0182 nan 0.0100 0.0000
100 0.0146 nan 0.0100 0.0001
120 0.0119 nan 0.0100 0.0001
140 0.0099 nan 0.0100 0.0001
160 0.0083 nan 0.0100 0.0001
180 0.0073 nan 0.0100 -0.0000
200 0.0062 nan 0.0100 0.0000
- Fold19: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold19: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0426 nan 0.0100 0.0003
2 0.0420 nan 0.0100 0.0002
3 0.0415 nan 0.0100 0.0002
4 0.0410 nan 0.0100 0.0005
5 0.0406 nan 0.0100 0.0005
6 0.0401 nan 0.0100 0.0003
7 0.0397 nan 0.0100 0.0004
8 0.0393 nan 0.0100 0.0003
9 0.0392 nan 0.0100 -0.0001
10 0.0388 nan 0.0100 0.0002
20 0.0345 nan 0.0100 0.0004
40 0.0272 nan 0.0100 -0.0002
60 0.0218 nan 0.0100 0.0001
80 0.0180 nan 0.0100 0.0001
100 0.0150 nan 0.0100 0.0001
120 0.0123 nan 0.0100 0.0001
140 0.0103 nan 0.0100 0.0001
160 0.0089 nan 0.0100 0.0001
180 0.0075 nan 0.0100 0.0000
200 0.0065 nan 0.0100 0.0000
- Fold19: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold19: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0426 nan 0.0100 0.0004
2 0.0420 nan 0.0100 0.0005
3 0.0415 nan 0.0100 0.0006
4 0.0410 nan 0.0100 0.0005
5 0.0406 nan 0.0100 0.0001
6 0.0401 nan 0.0100 0.0001
7 0.0397 nan 0.0100 0.0004
8 0.0390 nan 0.0100 0.0005
9 0.0386 nan 0.0100 0.0004
10 0.0381 nan 0.0100 0.0005
20 0.0340 nan 0.0100 0.0003
40 0.0275 nan 0.0100 -0.0000
60 0.0223 nan 0.0100 0.0002
80 0.0184 nan 0.0100 0.0002
100 0.0154 nan 0.0100 0.0001
120 0.0131 nan 0.0100 0.0001
140 0.0113 nan 0.0100 0.0001
160 0.0099 nan 0.0100 0.0000
180 0.0086 nan 0.0100 0.0001
200 0.0077 nan 0.0100 0.0000
- Fold19: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold19: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0424 nan 0.0100 0.0006
2 0.0418 nan 0.0100 0.0004
3 0.0411 nan 0.0100 0.0006
4 0.0403 nan 0.0100 0.0008
5 0.0396 nan 0.0100 0.0005
6 0.0390 nan 0.0100 0.0003
7 0.0384 nan 0.0100 0.0008
8 0.0377 nan 0.0100 0.0005
9 0.0373 nan 0.0100 0.0002
10 0.0368 nan 0.0100 0.0005
20 0.0324 nan 0.0100 0.0002
40 0.0247 nan 0.0100 0.0002
60 0.0193 nan 0.0100 0.0001
80 0.0153 nan 0.0100 -0.0001
100 0.0118 nan 0.0100 0.0001
120 0.0091 nan 0.0100 0.0001
140 0.0073 nan 0.0100 0.0000
160 0.0060 nan 0.0100 0.0000
180 0.0048 nan 0.0100 0.0000
200 0.0038 nan 0.0100 0.0000
- Fold19: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold19: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0427 nan 0.0100 0.0001
2 0.0424 nan 0.0100 0.0005
3 0.0419 nan 0.0100 0.0006
4 0.0412 nan 0.0100 0.0006
5 0.0406 nan 0.0100 0.0006
6 0.0399 nan 0.0100 0.0004
7 0.0393 nan 0.0100 0.0004
8 0.0389 nan 0.0100 0.0003
9 0.0383 nan 0.0100 0.0006
10 0.0377 nan 0.0100 0.0006
20 0.0329 nan 0.0100 -0.0001
40 0.0255 nan 0.0100 0.0003
60 0.0196 nan 0.0100 0.0003
80 0.0154 nan 0.0100 0.0002
100 0.0121 nan 0.0100 0.0001
120 0.0096 nan 0.0100 0.0001
140 0.0081 nan 0.0100 0.0001
160 0.0067 nan 0.0100 0.0000
180 0.0054 nan 0.0100 0.0000
200 0.0044 nan 0.0100 0.0000
- Fold19: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold19: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0425 nan 0.0100 0.0005
2 0.0421 nan 0.0100 0.0004
3 0.0415 nan 0.0100 0.0005
4 0.0410 nan 0.0100 0.0005
5 0.0405 nan 0.0100 0.0004
6 0.0401 nan 0.0100 0.0002
7 0.0395 nan 0.0100 0.0005
8 0.0389 nan 0.0100 0.0004
9 0.0387 nan 0.0100 0.0000
10 0.0383 nan 0.0100 0.0004
20 0.0346 nan 0.0100 0.0002
40 0.0280 nan 0.0100 0.0003
60 0.0228 nan 0.0100 0.0002
80 0.0190 nan 0.0100 0.0002
100 0.0162 nan 0.0100 0.0001
120 0.0136 nan 0.0100 -0.0000
140 0.0118 nan 0.0100 0.0000
160 0.0100 nan 0.0100 0.0000
180 0.0090 nan 0.0100 0.0000
200 0.0080 nan 0.0100 0.0000
- Fold19: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold19: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0425 nan 0.0100 0.0004
2 0.0417 nan 0.0100 0.0005
3 0.0410 nan 0.0100 0.0002
4 0.0403 nan 0.0100 0.0007
5 0.0398 nan 0.0100 0.0005
6 0.0390 nan 0.0100 0.0006
7 0.0384 nan 0.0100 0.0005
8 0.0381 nan 0.0100 0.0003
9 0.0378 nan 0.0100 -0.0001
10 0.0371 nan 0.0100 0.0005
20 0.0323 nan 0.0100 0.0002
40 0.0236 nan 0.0100 0.0001
60 0.0181 nan 0.0100 0.0001
80 0.0136 nan 0.0100 0.0001
100 0.0103 nan 0.0100 0.0002
120 0.0079 nan 0.0100 0.0001
140 0.0063 nan 0.0100 0.0001
160 0.0051 nan 0.0100 0.0000
180 0.0040 nan 0.0100 -0.0000
200 0.0031 nan 0.0100 0.0000
- Fold19: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold19: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0423 nan 0.0100 0.0007
2 0.0418 nan 0.0100 0.0005
3 0.0413 nan 0.0100 0.0005
4 0.0408 nan 0.0100 0.0004
5 0.0400 nan 0.0100 0.0008
6 0.0393 nan 0.0100 0.0006
7 0.0388 nan 0.0100 0.0002
8 0.0381 nan 0.0100 0.0005
9 0.0375 nan 0.0100 0.0006
10 0.0369 nan 0.0100 0.0006
20 0.0322 nan 0.0100 0.0001
40 0.0254 nan 0.0100 0.0002
60 0.0196 nan 0.0100 0.0002
80 0.0155 nan 0.0100 0.0002
100 0.0125 nan 0.0100 0.0000
120 0.0103 nan 0.0100 0.0001
140 0.0083 nan 0.0100 0.0000
160 0.0068 nan 0.0100 0.0001
180 0.0057 nan 0.0100 0.0000
200 0.0048 nan 0.0100 0.0000
- Fold19: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold19: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0425 nan 0.0100 0.0005
2 0.0418 nan 0.0100 0.0006
3 0.0414 nan 0.0100 0.0002
4 0.0409 nan 0.0100 0.0004
5 0.0403 nan 0.0100 0.0003
6 0.0398 nan 0.0100 0.0005
7 0.0392 nan 0.0100 0.0004
8 0.0388 nan 0.0100 0.0003
9 0.0384 nan 0.0100 0.0004
10 0.0381 nan 0.0100 0.0001
20 0.0337 nan 0.0100 0.0001
40 0.0268 nan 0.0100 0.0003
60 0.0220 nan 0.0100 0.0002
80 0.0182 nan 0.0100 -0.0001
100 0.0155 nan 0.0100 0.0000
120 0.0133 nan 0.0100 -0.0001
140 0.0114 nan 0.0100 0.0000
160 0.0099 nan 0.0100 0.0000
180 0.0089 nan 0.0100 -0.0000
200 0.0079 nan 0.0100 0.0000
- Fold19: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold19: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0409 nan 0.0500 0.0022
2 0.0390 nan 0.0500 0.0013
3 0.0359 nan 0.0500 0.0023
4 0.0337 nan 0.0500 0.0022
5 0.0315 nan 0.0500 0.0018
6 0.0295 nan 0.0500 0.0013
7 0.0274 nan 0.0500 0.0008
8 0.0260 nan 0.0500 0.0011
9 0.0245 nan 0.0500 0.0014
10 0.0230 nan 0.0500 0.0014
20 0.0141 nan 0.0500 0.0002
40 0.0059 nan 0.0500 0.0003
60 0.0033 nan 0.0500 0.0000
80 0.0019 nan 0.0500 -0.0000
100 0.0011 nan 0.0500 -0.0000
120 0.0006 nan 0.0500 -0.0000
140 0.0004 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0002 nan 0.0500 0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold19: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold19: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0399 nan 0.0500 0.0017
2 0.0393 nan 0.0500 -0.0007
3 0.0373 nan 0.0500 0.0015
4 0.0357 nan 0.0500 0.0015
5 0.0335 nan 0.0500 0.0014
6 0.0319 nan 0.0500 0.0013
7 0.0300 nan 0.0500 0.0019
8 0.0278 nan 0.0500 0.0017
9 0.0265 nan 0.0500 0.0004
10 0.0246 nan 0.0500 0.0015
20 0.0157 nan 0.0500 0.0005
40 0.0064 nan 0.0500 0.0000
60 0.0032 nan 0.0500 -0.0001
80 0.0018 nan 0.0500 0.0000
100 0.0011 nan 0.0500 -0.0000
120 0.0008 nan 0.0500 -0.0000
140 0.0005 nan 0.0500 0.0000
160 0.0003 nan 0.0500 -0.0000
180 0.0002 nan 0.0500 0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold19: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold19: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0401 nan 0.0500 0.0023
2 0.0379 nan 0.0500 0.0024
3 0.0360 nan 0.0500 0.0012
4 0.0341 nan 0.0500 0.0017
5 0.0322 nan 0.0500 0.0017
6 0.0308 nan 0.0500 0.0005
7 0.0282 nan 0.0500 0.0013
8 0.0264 nan 0.0500 0.0014
9 0.0247 nan 0.0500 0.0011
10 0.0237 nan 0.0500 0.0007
20 0.0161 nan 0.0500 0.0001
40 0.0090 nan 0.0500 0.0001
60 0.0051 nan 0.0500 0.0000
80 0.0034 nan 0.0500 -0.0000
100 0.0025 nan 0.0500 0.0000
120 0.0017 nan 0.0500 -0.0000
140 0.0012 nan 0.0500 0.0000
160 0.0009 nan 0.0500 0.0000
180 0.0007 nan 0.0500 -0.0000
200 0.0005 nan 0.0500 -0.0000
- Fold19: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold19: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0401 nan 0.0500 0.0023
2 0.0376 nan 0.0500 0.0018
3 0.0360 nan 0.0500 0.0014
4 0.0337 nan 0.0500 0.0019
5 0.0305 nan 0.0500 0.0021
6 0.0288 nan 0.0500 0.0008
7 0.0266 nan 0.0500 0.0009
8 0.0250 nan 0.0500 0.0010
9 0.0235 nan 0.0500 0.0011
10 0.0215 nan 0.0500 0.0010
20 0.0109 nan 0.0500 0.0006
40 0.0038 nan 0.0500 0.0002
60 0.0015 nan 0.0500 -0.0000
80 0.0007 nan 0.0500 0.0000
100 0.0003 nan 0.0500 0.0000
120 0.0002 nan 0.0500 -0.0000
140 0.0001 nan 0.0500 0.0000
160 0.0000 nan 0.0500 0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold19: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold19: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0405 nan 0.0500 0.0021
2 0.0375 nan 0.0500 0.0023
3 0.0351 nan 0.0500 0.0025
4 0.0327 nan 0.0500 0.0021
5 0.0305 nan 0.0500 0.0007
6 0.0291 nan 0.0500 0.0010
7 0.0272 nan 0.0500 0.0011
8 0.0261 nan 0.0500 0.0015
9 0.0240 nan 0.0500 0.0020
10 0.0223 nan 0.0500 0.0009
20 0.0118 nan 0.0500 0.0004
40 0.0046 nan 0.0500 0.0000
60 0.0020 nan 0.0500 -0.0000
80 0.0010 nan 0.0500 0.0000
100 0.0006 nan 0.0500 -0.0000
120 0.0003 nan 0.0500 0.0000
140 0.0002 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold19: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold19: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0409 nan 0.0500 0.0019
2 0.0382 nan 0.0500 0.0024
3 0.0360 nan 0.0500 0.0022
4 0.0335 nan 0.0500 0.0020
5 0.0314 nan 0.0500 0.0012
6 0.0307 nan 0.0500 -0.0004
7 0.0288 nan 0.0500 0.0019
8 0.0270 nan 0.0500 0.0016
9 0.0259 nan 0.0500 0.0006
10 0.0246 nan 0.0500 0.0013
20 0.0147 nan 0.0500 0.0007
40 0.0072 nan 0.0500 -0.0001
60 0.0045 nan 0.0500 0.0001
80 0.0030 nan 0.0500 0.0000
100 0.0019 nan 0.0500 -0.0000
120 0.0013 nan 0.0500 -0.0000
140 0.0009 nan 0.0500 -0.0000
160 0.0006 nan 0.0500 0.0000
180 0.0005 nan 0.0500 -0.0000
200 0.0003 nan 0.0500 0.0000
- Fold19: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold19: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0403 nan 0.0500 0.0022
2 0.0369 nan 0.0500 0.0026
3 0.0338 nan 0.0500 0.0019
4 0.0310 nan 0.0500 0.0017
5 0.0288 nan 0.0500 0.0015
6 0.0268 nan 0.0500 0.0023
7 0.0247 nan 0.0500 0.0022
8 0.0230 nan 0.0500 0.0014
9 0.0215 nan 0.0500 0.0009
10 0.0200 nan 0.0500 0.0020
20 0.0104 nan 0.0500 0.0008
40 0.0029 nan 0.0500 0.0000
60 0.0010 nan 0.0500 -0.0000
80 0.0004 nan 0.0500 -0.0000
100 0.0002 nan 0.0500 -0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0000 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold19: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold19: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0412 nan 0.0500 0.0007
2 0.0395 nan 0.0500 0.0022
3 0.0374 nan 0.0500 0.0002
4 0.0349 nan 0.0500 0.0027
5 0.0320 nan 0.0500 0.0022
6 0.0303 nan 0.0500 0.0018
7 0.0289 nan 0.0500 0.0004
8 0.0280 nan 0.0500 0.0002
9 0.0260 nan 0.0500 0.0015
10 0.0244 nan 0.0500 0.0006
20 0.0133 nan 0.0500 0.0004
40 0.0043 nan 0.0500 0.0001
60 0.0018 nan 0.0500 -0.0000
80 0.0009 nan 0.0500 -0.0000
100 0.0005 nan 0.0500 -0.0000
120 0.0003 nan 0.0500 -0.0000
140 0.0002 nan 0.0500 -0.0000
160 0.0001 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold19: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold19: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0411 nan 0.0500 0.0009
2 0.0398 nan 0.0500 0.0009
3 0.0369 nan 0.0500 0.0028
4 0.0350 nan 0.0500 0.0010
5 0.0335 nan 0.0500 0.0002
6 0.0318 nan 0.0500 0.0007
7 0.0306 nan 0.0500 0.0003
8 0.0285 nan 0.0500 0.0019
9 0.0273 nan 0.0500 0.0009
10 0.0262 nan 0.0500 0.0008
20 0.0165 nan 0.0500 0.0004
40 0.0080 nan 0.0500 0.0002
60 0.0045 nan 0.0500 -0.0000
80 0.0028 nan 0.0500 -0.0000
100 0.0020 nan 0.0500 0.0000
120 0.0013 nan 0.0500 -0.0000
140 0.0010 nan 0.0500 0.0000
160 0.0007 nan 0.0500 0.0000
180 0.0005 nan 0.0500 -0.0000
200 0.0004 nan 0.0500 -0.0000
- Fold19: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold19: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0413 nan 0.1000 -0.0006
2 0.0361 nan 0.1000 0.0047
3 0.0309 nan 0.1000 0.0024
4 0.0292 nan 0.1000 0.0008
5 0.0266 nan 0.1000 0.0011
6 0.0244 nan 0.1000 0.0013
7 0.0211 nan 0.1000 0.0027
8 0.0194 nan 0.1000 0.0002
9 0.0188 nan 0.1000 -0.0004
10 0.0179 nan 0.1000 0.0005
20 0.0070 nan 0.1000 0.0006
40 0.0019 nan 0.1000 -0.0002
60 0.0006 nan 0.1000 -0.0000
80 0.0003 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold19: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold19: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0404 nan 0.1000 0.0004
2 0.0369 nan 0.1000 0.0006
3 0.0331 nan 0.1000 0.0037
4 0.0311 nan 0.1000 0.0011
5 0.0284 nan 0.1000 0.0003
6 0.0250 nan 0.1000 0.0031
7 0.0239 nan 0.1000 -0.0003
8 0.0222 nan 0.1000 0.0010
9 0.0194 nan 0.1000 0.0009
10 0.0176 nan 0.1000 0.0013
20 0.0069 nan 0.1000 0.0000
40 0.0023 nan 0.1000 -0.0001
60 0.0008 nan 0.1000 -0.0000
80 0.0003 nan 0.1000 0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold19: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold19: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0377 nan 0.1000 0.0052
2 0.0326 nan 0.1000 0.0037
3 0.0301 nan 0.1000 0.0017
4 0.0268 nan 0.1000 0.0028
5 0.0237 nan 0.1000 0.0029
6 0.0219 nan 0.1000 0.0009
7 0.0214 nan 0.1000 0.0001
8 0.0194 nan 0.1000 0.0006
9 0.0174 nan 0.1000 0.0012
10 0.0161 nan 0.1000 0.0006
20 0.0097 nan 0.1000 -0.0003
40 0.0033 nan 0.1000 -0.0001
60 0.0015 nan 0.1000 -0.0000
80 0.0007 nan 0.1000 0.0000
100 0.0004 nan 0.1000 -0.0000
120 0.0002 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 0.0000
- Fold19: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold19: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0373 nan 0.1000 0.0053
2 0.0337 nan 0.1000 0.0002
3 0.0291 nan 0.1000 0.0046
4 0.0272 nan 0.1000 -0.0007
5 0.0239 nan 0.1000 0.0019
6 0.0210 nan 0.1000 0.0021
7 0.0179 nan 0.1000 0.0016
8 0.0158 nan 0.1000 0.0014
9 0.0130 nan 0.1000 0.0020
10 0.0116 nan 0.1000 0.0011
20 0.0044 nan 0.1000 0.0002
40 0.0010 nan 0.1000 0.0002
60 0.0003 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold19: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold19: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0365 nan 0.1000 0.0060
2 0.0305 nan 0.1000 0.0036
3 0.0271 nan 0.1000 0.0010
4 0.0229 nan 0.1000 0.0012
5 0.0207 nan 0.1000 0.0012
6 0.0178 nan 0.1000 0.0019
7 0.0160 nan 0.1000 0.0016
8 0.0149 nan 0.1000 -0.0006
9 0.0128 nan 0.1000 0.0013
10 0.0108 nan 0.1000 0.0013
20 0.0037 nan 0.1000 0.0004
40 0.0010 nan 0.1000 -0.0001
60 0.0003 nan 0.1000 -0.0000
80 0.0002 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold19: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold19: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0373 nan 0.1000 0.0056
2 0.0340 nan 0.1000 0.0019
3 0.0303 nan 0.1000 0.0027
4 0.0274 nan 0.1000 0.0016
5 0.0246 nan 0.1000 0.0019
6 0.0220 nan 0.1000 0.0027
7 0.0195 nan 0.1000 0.0022
8 0.0175 nan 0.1000 0.0018
9 0.0159 nan 0.1000 0.0016
10 0.0148 nan 0.1000 0.0003
20 0.0091 nan 0.1000 -0.0005
40 0.0043 nan 0.1000 -0.0002
60 0.0018 nan 0.1000 0.0000
80 0.0009 nan 0.1000 0.0000
100 0.0004 nan 0.1000 -0.0000
120 0.0002 nan 0.1000 0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 0.0000
- Fold19: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold19: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0356 nan 0.1000 0.0052
2 0.0291 nan 0.1000 0.0045
3 0.0249 nan 0.1000 0.0032
4 0.0216 nan 0.1000 0.0024
5 0.0192 nan 0.1000 0.0016
6 0.0171 nan 0.1000 0.0009
7 0.0145 nan 0.1000 0.0027
8 0.0125 nan 0.1000 0.0017
9 0.0108 nan 0.1000 0.0013
10 0.0101 nan 0.1000 0.0005
20 0.0034 nan 0.1000 -0.0001
40 0.0007 nan 0.1000 -0.0001
60 0.0002 nan 0.1000 -0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold19: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold19: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0352 nan 0.1000 0.0029
2 0.0312 nan 0.1000 0.0027
3 0.0276 nan 0.1000 0.0028
4 0.0238 nan 0.1000 0.0037
5 0.0200 nan 0.1000 0.0036
6 0.0188 nan 0.1000 0.0004
7 0.0170 nan 0.1000 0.0003
8 0.0153 nan 0.1000 0.0013
9 0.0126 nan 0.1000 0.0015
10 0.0113 nan 0.1000 0.0006
20 0.0045 nan 0.1000 0.0005
40 0.0009 nan 0.1000 0.0000
60 0.0003 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold19: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold19: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0369 nan 0.1000 0.0056
2 0.0330 nan 0.1000 0.0041
3 0.0296 nan 0.1000 0.0038
4 0.0259 nan 0.1000 0.0010
5 0.0237 nan 0.1000 0.0010
6 0.0208 nan 0.1000 0.0023
7 0.0192 nan 0.1000 0.0012
8 0.0177 nan 0.1000 0.0015
9 0.0162 nan 0.1000 0.0013
10 0.0148 nan 0.1000 0.0015
20 0.0098 nan 0.1000 -0.0004
40 0.0035 nan 0.1000 0.0001
60 0.0012 nan 0.1000 0.0001
80 0.0007 nan 0.1000 -0.0000
100 0.0003 nan 0.1000 -0.0000
120 0.0002 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold19: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold20: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0433 nan 0.0100 0.0006
2 0.0430 nan 0.0100 0.0001
3 0.0424 nan 0.0100 0.0005
4 0.0420 nan 0.0100 0.0003
5 0.0416 nan 0.0100 0.0003
6 0.0410 nan 0.0100 0.0006
7 0.0408 nan 0.0100 -0.0002
8 0.0403 nan 0.0100 0.0005
9 0.0398 nan 0.0100 0.0004
10 0.0393 nan 0.0100 0.0002
20 0.0346 nan 0.0100 0.0003
40 0.0275 nan 0.0100 0.0002
60 0.0225 nan 0.0100 0.0003
80 0.0179 nan 0.0100 0.0002
100 0.0145 nan 0.0100 0.0002
120 0.0119 nan 0.0100 0.0001
140 0.0098 nan 0.0100 0.0001
160 0.0080 nan 0.0100 0.0001
180 0.0067 nan 0.0100 0.0000
200 0.0056 nan 0.0100 -0.0000
- Fold20: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold20: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0436 nan 0.0100 0.0003
2 0.0429 nan 0.0100 0.0005
3 0.0424 nan 0.0100 0.0003
4 0.0418 nan 0.0100 0.0004
5 0.0413 nan 0.0100 0.0005
6 0.0408 nan 0.0100 0.0005
7 0.0403 nan 0.0100 0.0006
8 0.0397 nan 0.0100 0.0007
9 0.0393 nan 0.0100 0.0002
10 0.0387 nan 0.0100 0.0005
20 0.0350 nan 0.0100 0.0004
40 0.0277 nan 0.0100 0.0001
60 0.0226 nan 0.0100 0.0002
80 0.0184 nan 0.0100 0.0002
100 0.0154 nan 0.0100 0.0002
120 0.0127 nan 0.0100 0.0001
140 0.0107 nan 0.0100 0.0001
160 0.0090 nan 0.0100 0.0001
180 0.0076 nan 0.0100 0.0001
200 0.0066 nan 0.0100 0.0001
- Fold20: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold20: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0433 nan 0.0100 0.0006
2 0.0427 nan 0.0100 0.0001
3 0.0420 nan 0.0100 0.0005
4 0.0414 nan 0.0100 0.0005
5 0.0409 nan 0.0100 0.0005
6 0.0403 nan 0.0100 0.0006
7 0.0400 nan 0.0100 0.0004
8 0.0394 nan 0.0100 0.0005
9 0.0389 nan 0.0100 0.0001
10 0.0385 nan 0.0100 0.0004
20 0.0343 nan 0.0100 0.0000
40 0.0274 nan 0.0100 0.0002
60 0.0228 nan 0.0100 0.0000
80 0.0184 nan 0.0100 0.0002
100 0.0155 nan 0.0100 0.0001
120 0.0132 nan 0.0100 -0.0000
140 0.0114 nan 0.0100 0.0001
160 0.0099 nan 0.0100 0.0000
180 0.0087 nan 0.0100 0.0001
200 0.0078 nan 0.0100 0.0000
- Fold20: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold20: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0432 nan 0.0100 0.0006
2 0.0425 nan 0.0100 0.0007
3 0.0421 nan 0.0100 0.0003
4 0.0414 nan 0.0100 0.0006
5 0.0407 nan 0.0100 0.0005
6 0.0402 nan 0.0100 0.0001
7 0.0398 nan 0.0100 0.0004
8 0.0393 nan 0.0100 0.0005
9 0.0387 nan 0.0100 0.0005
10 0.0382 nan 0.0100 0.0002
20 0.0328 nan 0.0100 0.0003
40 0.0252 nan 0.0100 0.0002
60 0.0192 nan 0.0100 0.0003
80 0.0147 nan 0.0100 0.0002
100 0.0119 nan 0.0100 0.0001
120 0.0096 nan 0.0100 0.0001
140 0.0077 nan 0.0100 0.0001
160 0.0062 nan 0.0100 0.0000
180 0.0050 nan 0.0100 -0.0000
200 0.0042 nan 0.0100 0.0000
- Fold20: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold20: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0436 nan 0.0100 0.0001
2 0.0429 nan 0.0100 0.0006
3 0.0424 nan 0.0100 0.0005
4 0.0417 nan 0.0100 0.0005
5 0.0412 nan 0.0100 0.0006
6 0.0406 nan 0.0100 0.0006
7 0.0400 nan 0.0100 0.0005
8 0.0394 nan 0.0100 0.0004
9 0.0388 nan 0.0100 0.0006
10 0.0381 nan 0.0100 0.0005
20 0.0332 nan 0.0100 0.0004
40 0.0254 nan 0.0100 0.0002
60 0.0199 nan 0.0100 0.0000
80 0.0159 nan 0.0100 0.0002
100 0.0125 nan 0.0100 0.0002
120 0.0100 nan 0.0100 0.0000
140 0.0080 nan 0.0100 -0.0000
160 0.0066 nan 0.0100 0.0000
180 0.0054 nan 0.0100 0.0000
200 0.0044 nan 0.0100 0.0000
- Fold20: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold20: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0434 nan 0.0100 0.0004
2 0.0431 nan 0.0100 -0.0001
3 0.0425 nan 0.0100 0.0006
4 0.0419 nan 0.0100 0.0005
5 0.0413 nan 0.0100 0.0006
6 0.0406 nan 0.0100 0.0005
7 0.0401 nan 0.0100 0.0002
8 0.0398 nan 0.0100 0.0002
9 0.0392 nan 0.0100 0.0006
10 0.0388 nan 0.0100 0.0002
20 0.0346 nan 0.0100 0.0002
40 0.0276 nan 0.0100 0.0003
60 0.0222 nan 0.0100 0.0001
80 0.0183 nan 0.0100 0.0001
100 0.0152 nan 0.0100 0.0001
120 0.0128 nan 0.0100 0.0001
140 0.0110 nan 0.0100 0.0001
160 0.0096 nan 0.0100 -0.0000
180 0.0085 nan 0.0100 0.0001
200 0.0076 nan 0.0100 0.0000
- Fold20: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold20: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0432 nan 0.0100 0.0006
2 0.0426 nan 0.0100 0.0005
3 0.0420 nan 0.0100 0.0003
4 0.0417 nan 0.0100 -0.0001
5 0.0411 nan 0.0100 0.0005
6 0.0406 nan 0.0100 0.0005
7 0.0399 nan 0.0100 0.0004
8 0.0394 nan 0.0100 0.0004
9 0.0388 nan 0.0100 0.0004
10 0.0383 nan 0.0100 0.0004
20 0.0325 nan 0.0100 0.0002
40 0.0250 nan 0.0100 0.0002
60 0.0189 nan 0.0100 0.0001
80 0.0148 nan 0.0100 0.0002
100 0.0113 nan 0.0100 0.0001
120 0.0089 nan 0.0100 0.0001
140 0.0068 nan 0.0100 0.0001
160 0.0054 nan 0.0100 -0.0000
180 0.0043 nan 0.0100 0.0000
200 0.0034 nan 0.0100 0.0000
- Fold20: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold20: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0431 nan 0.0100 0.0004
2 0.0427 nan 0.0100 0.0003
3 0.0422 nan 0.0100 0.0004
4 0.0417 nan 0.0100 0.0004
5 0.0410 nan 0.0100 0.0006
6 0.0405 nan 0.0100 0.0004
7 0.0398 nan 0.0100 0.0007
8 0.0392 nan 0.0100 0.0004
9 0.0387 nan 0.0100 0.0004
10 0.0382 nan 0.0100 0.0001
20 0.0332 nan 0.0100 0.0003
40 0.0255 nan 0.0100 0.0001
60 0.0192 nan 0.0100 0.0003
80 0.0154 nan 0.0100 0.0001
100 0.0121 nan 0.0100 0.0000
120 0.0095 nan 0.0100 0.0000
140 0.0076 nan 0.0100 0.0001
160 0.0059 nan 0.0100 0.0000
180 0.0047 nan 0.0100 0.0001
200 0.0039 nan 0.0100 0.0000
- Fold20: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold20: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0435 nan 0.0100 0.0005
2 0.0428 nan 0.0100 0.0005
3 0.0419 nan 0.0100 0.0006
4 0.0415 nan 0.0100 0.0006
5 0.0409 nan 0.0100 0.0002
6 0.0404 nan 0.0100 0.0005
7 0.0401 nan 0.0100 0.0002
8 0.0396 nan 0.0100 0.0002
9 0.0393 nan 0.0100 0.0002
10 0.0390 nan 0.0100 0.0003
20 0.0348 nan 0.0100 0.0004
40 0.0280 nan 0.0100 0.0001
60 0.0227 nan 0.0100 0.0000
80 0.0185 nan 0.0100 0.0002
100 0.0152 nan 0.0100 0.0001
120 0.0131 nan 0.0100 0.0001
140 0.0113 nan 0.0100 0.0001
160 0.0098 nan 0.0100 0.0000
180 0.0088 nan 0.0100 -0.0000
200 0.0078 nan 0.0100 0.0000
- Fold20: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold20: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0410 nan 0.0500 0.0028
2 0.0382 nan 0.0500 0.0023
3 0.0362 nan 0.0500 0.0024
4 0.0343 nan 0.0500 0.0019
5 0.0322 nan 0.0500 0.0020
6 0.0302 nan 0.0500 0.0017
7 0.0290 nan 0.0500 0.0010
8 0.0272 nan 0.0500 0.0018
9 0.0262 nan 0.0500 0.0007
10 0.0254 nan 0.0500 0.0002
20 0.0155 nan 0.0500 0.0004
40 0.0069 nan 0.0500 -0.0001
60 0.0034 nan 0.0500 0.0001
80 0.0017 nan 0.0500 0.0000
100 0.0011 nan 0.0500 -0.0001
120 0.0007 nan 0.0500 0.0000
140 0.0004 nan 0.0500 -0.0000
160 0.0003 nan 0.0500 -0.0000
180 0.0002 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold20: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold20: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0409 nan 0.0500 0.0030
2 0.0390 nan 0.0500 0.0016
3 0.0365 nan 0.0500 0.0014
4 0.0340 nan 0.0500 0.0026
5 0.0325 nan 0.0500 -0.0001
6 0.0299 nan 0.0500 0.0025
7 0.0285 nan 0.0500 0.0017
8 0.0268 nan 0.0500 0.0015
9 0.0250 nan 0.0500 0.0012
10 0.0233 nan 0.0500 0.0015
20 0.0141 nan 0.0500 0.0007
40 0.0061 nan 0.0500 0.0003
60 0.0031 nan 0.0500 -0.0001
80 0.0018 nan 0.0500 0.0000
100 0.0011 nan 0.0500 0.0000
120 0.0007 nan 0.0500 0.0000
140 0.0005 nan 0.0500 0.0000
160 0.0003 nan 0.0500 0.0000
180 0.0002 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 0.0000
- Fold20: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold20: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0416 nan 0.0500 0.0029
2 0.0392 nan 0.0500 0.0021
3 0.0375 nan 0.0500 0.0023
4 0.0351 nan 0.0500 0.0016
5 0.0330 nan 0.0500 0.0021
6 0.0311 nan 0.0500 0.0017
7 0.0295 nan 0.0500 0.0015
8 0.0284 nan 0.0500 0.0001
9 0.0274 nan 0.0500 -0.0003
10 0.0269 nan 0.0500 -0.0004
20 0.0176 nan 0.0500 0.0009
40 0.0094 nan 0.0500 0.0001
60 0.0052 nan 0.0500 -0.0000
80 0.0035 nan 0.0500 -0.0001
100 0.0025 nan 0.0500 -0.0000
120 0.0017 nan 0.0500 0.0000
140 0.0012 nan 0.0500 0.0000
160 0.0009 nan 0.0500 -0.0000
180 0.0007 nan 0.0500 -0.0000
200 0.0005 nan 0.0500 -0.0000
- Fold20: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold20: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0414 nan 0.0500 0.0019
2 0.0381 nan 0.0500 0.0020
3 0.0363 nan 0.0500 0.0010
4 0.0338 nan 0.0500 0.0020
5 0.0309 nan 0.0500 0.0016
6 0.0295 nan 0.0500 0.0014
7 0.0276 nan 0.0500 0.0018
8 0.0257 nan 0.0500 0.0019
9 0.0235 nan 0.0500 0.0012
10 0.0221 nan 0.0500 0.0014
20 0.0134 nan 0.0500 0.0001
40 0.0036 nan 0.0500 0.0001
60 0.0015 nan 0.0500 -0.0000
80 0.0007 nan 0.0500 0.0000
100 0.0003 nan 0.0500 -0.0000
120 0.0001 nan 0.0500 0.0000
140 0.0001 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold20: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold20: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0408 nan 0.0500 0.0029
2 0.0372 nan 0.0500 0.0033
3 0.0357 nan 0.0500 0.0009
4 0.0336 nan 0.0500 0.0017
5 0.0314 nan 0.0500 0.0016
6 0.0285 nan 0.0500 0.0014
7 0.0274 nan 0.0500 0.0005
8 0.0255 nan 0.0500 0.0005
9 0.0239 nan 0.0500 0.0014
10 0.0222 nan 0.0500 0.0018
20 0.0137 nan 0.0500 0.0002
40 0.0054 nan 0.0500 -0.0002
60 0.0023 nan 0.0500 0.0001
80 0.0011 nan 0.0500 -0.0000
100 0.0007 nan 0.0500 0.0000
120 0.0005 nan 0.0500 -0.0000
140 0.0003 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold20: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold20: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0407 nan 0.0500 0.0025
2 0.0379 nan 0.0500 0.0027
3 0.0360 nan 0.0500 -0.0001
4 0.0337 nan 0.0500 0.0016
5 0.0317 nan 0.0500 0.0021
6 0.0302 nan 0.0500 0.0017
7 0.0281 nan 0.0500 0.0017
8 0.0262 nan 0.0500 0.0014
9 0.0254 nan 0.0500 0.0004
10 0.0243 nan 0.0500 0.0014
20 0.0161 nan 0.0500 0.0002
40 0.0080 nan 0.0500 -0.0001
60 0.0049 nan 0.0500 -0.0001
80 0.0032 nan 0.0500 -0.0001
100 0.0024 nan 0.0500 -0.0001
120 0.0018 nan 0.0500 0.0000
140 0.0013 nan 0.0500 -0.0000
160 0.0009 nan 0.0500 -0.0000
180 0.0007 nan 0.0500 0.0000
200 0.0005 nan 0.0500 -0.0000
- Fold20: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold20: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0400 nan 0.0500 0.0046
2 0.0366 nan 0.0500 0.0030
3 0.0342 nan 0.0500 0.0023
4 0.0314 nan 0.0500 0.0015
5 0.0290 nan 0.0500 0.0013
6 0.0261 nan 0.0500 0.0027
7 0.0253 nan 0.0500 -0.0004
8 0.0229 nan 0.0500 0.0009
9 0.0213 nan 0.0500 0.0003
10 0.0200 nan 0.0500 0.0007
20 0.0104 nan 0.0500 0.0003
40 0.0031 nan 0.0500 -0.0001
60 0.0011 nan 0.0500 -0.0000
80 0.0004 nan 0.0500 -0.0000
100 0.0002 nan 0.0500 -0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0000 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold20: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold20: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0422 nan 0.0500 0.0016
2 0.0392 nan 0.0500 0.0025
3 0.0365 nan 0.0500 0.0029
4 0.0344 nan 0.0500 0.0010
5 0.0315 nan 0.0500 0.0028
6 0.0295 nan 0.0500 0.0017
7 0.0275 nan 0.0500 0.0003
8 0.0252 nan 0.0500 0.0013
9 0.0238 nan 0.0500 0.0009
10 0.0223 nan 0.0500 0.0013
20 0.0129 nan 0.0500 0.0002
40 0.0049 nan 0.0500 0.0002
60 0.0022 nan 0.0500 0.0001
80 0.0012 nan 0.0500 -0.0000
100 0.0006 nan 0.0500 -0.0000
120 0.0004 nan 0.0500 -0.0000
140 0.0003 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold20: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold20: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0416 nan 0.0500 0.0015
2 0.0385 nan 0.0500 0.0021
3 0.0369 nan 0.0500 0.0018
4 0.0344 nan 0.0500 0.0010
5 0.0328 nan 0.0500 0.0016
6 0.0307 nan 0.0500 0.0022
7 0.0287 nan 0.0500 0.0020
8 0.0267 nan 0.0500 0.0016
9 0.0255 nan 0.0500 0.0008
10 0.0240 nan 0.0500 0.0015
20 0.0148 nan 0.0500 0.0006
40 0.0071 nan 0.0500 0.0002
60 0.0047 nan 0.0500 0.0001
80 0.0030 nan 0.0500 0.0000
100 0.0021 nan 0.0500 0.0000
120 0.0014 nan 0.0500 0.0000
140 0.0011 nan 0.0500 -0.0000
160 0.0008 nan 0.0500 0.0000
180 0.0006 nan 0.0500 -0.0000
200 0.0004 nan 0.0500 -0.0000
- Fold20: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold20: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0377 nan 0.1000 0.0042
2 0.0327 nan 0.1000 0.0049
3 0.0288 nan 0.1000 0.0019
4 0.0253 nan 0.1000 0.0029
5 0.0233 nan 0.1000 -0.0011
6 0.0199 nan 0.1000 0.0038
7 0.0172 nan 0.1000 0.0025
8 0.0159 nan 0.1000 0.0012
9 0.0140 nan 0.1000 0.0021
10 0.0122 nan 0.1000 0.0021
20 0.0051 nan 0.1000 0.0007
40 0.0013 nan 0.1000 0.0001
60 0.0005 nan 0.1000 0.0000
80 0.0002 nan 0.1000 0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold20: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold20: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0400 nan 0.1000 -0.0007
2 0.0343 nan 0.1000 0.0042
3 0.0306 nan 0.1000 0.0042
4 0.0272 nan 0.1000 0.0036
5 0.0242 nan 0.1000 0.0013
6 0.0224 nan 0.1000 0.0007
7 0.0203 nan 0.1000 0.0015
8 0.0181 nan 0.1000 0.0024
9 0.0164 nan 0.1000 0.0011
10 0.0147 nan 0.1000 0.0015
20 0.0063 nan 0.1000 0.0002
40 0.0019 nan 0.1000 -0.0002
60 0.0009 nan 0.1000 0.0000
80 0.0004 nan 0.1000 0.0000
100 0.0002 nan 0.1000 0.0000
120 0.0001 nan 0.1000 0.0000
140 0.0000 nan 0.1000 0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 0.0000
200 0.0000 nan 0.1000 0.0000
- Fold20: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold20: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0392 nan 0.1000 0.0030
2 0.0367 nan 0.1000 0.0024
3 0.0318 nan 0.1000 0.0021
4 0.0269 nan 0.1000 0.0031
5 0.0235 nan 0.1000 0.0028
6 0.0208 nan 0.1000 0.0016
7 0.0194 nan 0.1000 0.0009
8 0.0176 nan 0.1000 0.0017
9 0.0162 nan 0.1000 0.0014
10 0.0161 nan 0.1000 -0.0006
20 0.0086 nan 0.1000 0.0005
40 0.0038 nan 0.1000 0.0001
60 0.0018 nan 0.1000 -0.0000
80 0.0011 nan 0.1000 -0.0000
100 0.0006 nan 0.1000 0.0000
120 0.0004 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold20: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold20: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0380 nan 0.1000 0.0021
2 0.0312 nan 0.1000 0.0049
3 0.0284 nan 0.1000 0.0008
4 0.0252 nan 0.1000 0.0033
5 0.0217 nan 0.1000 0.0027
6 0.0194 nan 0.1000 0.0019
7 0.0169 nan 0.1000 0.0018
8 0.0159 nan 0.1000 -0.0002
9 0.0137 nan 0.1000 0.0007
10 0.0122 nan 0.1000 0.0014
20 0.0038 nan 0.1000 0.0003
40 0.0006 nan 0.1000 0.0000
60 0.0002 nan 0.1000 -0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold20: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold20: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0368 nan 0.1000 0.0064
2 0.0341 nan 0.1000 -0.0011
3 0.0303 nan 0.1000 0.0032
4 0.0260 nan 0.1000 0.0020
5 0.0233 nan 0.1000 0.0028
6 0.0209 nan 0.1000 0.0018
7 0.0198 nan 0.1000 -0.0010
8 0.0181 nan 0.1000 0.0009
9 0.0162 nan 0.1000 0.0010
10 0.0145 nan 0.1000 0.0022
20 0.0053 nan 0.1000 0.0004
40 0.0012 nan 0.1000 0.0000
60 0.0004 nan 0.1000 0.0000
80 0.0002 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold20: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold20: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0392 nan 0.1000 0.0021
2 0.0350 nan 0.1000 0.0046
3 0.0314 nan 0.1000 0.0023
4 0.0281 nan 0.1000 0.0031
5 0.0252 nan 0.1000 0.0023
6 0.0216 nan 0.1000 0.0022
7 0.0198 nan 0.1000 0.0015
8 0.0186 nan 0.1000 0.0005
9 0.0163 nan 0.1000 0.0018
10 0.0142 nan 0.1000 0.0014
20 0.0060 nan 0.1000 0.0000
40 0.0026 nan 0.1000 0.0001
60 0.0012 nan 0.1000 -0.0000
80 0.0009 nan 0.1000 -0.0001
100 0.0004 nan 0.1000 -0.0000
120 0.0003 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 0.0000
200 0.0000 nan 0.1000 0.0000
- Fold20: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold20: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0369 nan 0.1000 0.0071
2 0.0317 nan 0.1000 0.0032
3 0.0271 nan 0.1000 0.0029
4 0.0223 nan 0.1000 0.0041
5 0.0191 nan 0.1000 0.0018
6 0.0178 nan 0.1000 0.0008
7 0.0155 nan 0.1000 0.0013
8 0.0135 nan 0.1000 0.0020
9 0.0123 nan 0.1000 0.0006
10 0.0115 nan 0.1000 -0.0010
20 0.0041 nan 0.1000 -0.0001
40 0.0006 nan 0.1000 -0.0000
60 0.0001 nan 0.1000 -0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold20: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold20: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0377 nan 0.1000 0.0065
2 0.0312 nan 0.1000 0.0052
3 0.0255 nan 0.1000 0.0047
4 0.0220 nan 0.1000 0.0025
5 0.0188 nan 0.1000 0.0014
6 0.0156 nan 0.1000 0.0018
7 0.0135 nan 0.1000 0.0017
8 0.0119 nan 0.1000 0.0009
9 0.0102 nan 0.1000 0.0010
10 0.0092 nan 0.1000 0.0008
20 0.0033 nan 0.1000 0.0000
40 0.0010 nan 0.1000 -0.0000
60 0.0004 nan 0.1000 -0.0000
80 0.0002 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold20: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold20: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0380 nan 0.1000 0.0029
2 0.0327 nan 0.1000 0.0034
3 0.0295 nan 0.1000 0.0023
4 0.0257 nan 0.1000 0.0010
5 0.0231 nan 0.1000 0.0023
6 0.0228 nan 0.1000 -0.0019
7 0.0208 nan 0.1000 -0.0007
8 0.0187 nan 0.1000 0.0023
9 0.0168 nan 0.1000 0.0012
10 0.0149 nan 0.1000 0.0001
20 0.0094 nan 0.1000 -0.0008
40 0.0033 nan 0.1000 -0.0001
60 0.0022 nan 0.1000 -0.0000
80 0.0013 nan 0.1000 -0.0001
100 0.0008 nan 0.1000 -0.0001
120 0.0005 nan 0.1000 0.0000
140 0.0003 nan 0.1000 -0.0000
160 0.0002 nan 0.1000 -0.0000
180 0.0002 nan 0.1000 0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold20: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold21: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0416 nan 0.0100 0.0001
2 0.0411 nan 0.0100 0.0006
3 0.0405 nan 0.0100 0.0006
4 0.0401 nan 0.0100 0.0004
5 0.0399 nan 0.0100 0.0000
6 0.0396 nan 0.0100 0.0002
7 0.0391 nan 0.0100 0.0003
8 0.0388 nan 0.0100 0.0002
9 0.0383 nan 0.0100 0.0005
10 0.0379 nan 0.0100 0.0005
20 0.0341 nan 0.0100 -0.0000
40 0.0268 nan 0.0100 0.0003
60 0.0225 nan 0.0100 -0.0000
80 0.0180 nan 0.0100 0.0001
100 0.0149 nan 0.0100 0.0001
120 0.0123 nan 0.0100 0.0000
140 0.0105 nan 0.0100 -0.0000
160 0.0089 nan 0.0100 0.0001
180 0.0075 nan 0.0100 0.0000
200 0.0063 nan 0.0100 0.0000
- Fold21: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold21: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0414 nan 0.0100 0.0005
2 0.0410 nan 0.0100 0.0004
3 0.0404 nan 0.0100 0.0005
4 0.0399 nan 0.0100 0.0005
5 0.0394 nan 0.0100 0.0004
6 0.0391 nan 0.0100 0.0000
7 0.0386 nan 0.0100 0.0004
8 0.0381 nan 0.0100 0.0006
9 0.0377 nan 0.0100 0.0004
10 0.0373 nan 0.0100 0.0004
20 0.0333 nan 0.0100 0.0001
40 0.0269 nan 0.0100 0.0003
60 0.0217 nan 0.0100 0.0000
80 0.0176 nan 0.0100 0.0002
100 0.0144 nan 0.0100 0.0000
120 0.0121 nan 0.0100 0.0000
140 0.0102 nan 0.0100 -0.0001
160 0.0087 nan 0.0100 0.0000
180 0.0075 nan 0.0100 0.0000
200 0.0065 nan 0.0100 0.0000
- Fold21: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold21: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0415 nan 0.0100 0.0001
2 0.0414 nan 0.0100 0.0001
3 0.0409 nan 0.0100 0.0005
4 0.0402 nan 0.0100 0.0005
5 0.0398 nan 0.0100 0.0004
6 0.0393 nan 0.0100 0.0003
7 0.0388 nan 0.0100 0.0004
8 0.0382 nan 0.0100 0.0005
9 0.0379 nan 0.0100 0.0003
10 0.0375 nan 0.0100 0.0002
20 0.0337 nan 0.0100 0.0004
40 0.0268 nan 0.0100 0.0003
60 0.0218 nan 0.0100 0.0002
80 0.0181 nan 0.0100 0.0001
100 0.0151 nan 0.0100 0.0000
120 0.0131 nan 0.0100 -0.0000
140 0.0114 nan 0.0100 -0.0000
160 0.0102 nan 0.0100 0.0000
180 0.0090 nan 0.0100 0.0000
200 0.0079 nan 0.0100 0.0000
- Fold21: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold21: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0417 nan 0.0100 -0.0003
2 0.0410 nan 0.0100 0.0006
3 0.0405 nan 0.0100 0.0003
4 0.0400 nan 0.0100 0.0006
5 0.0394 nan 0.0100 0.0006
6 0.0388 nan 0.0100 0.0005
7 0.0382 nan 0.0100 0.0004
8 0.0378 nan 0.0100 0.0002
9 0.0373 nan 0.0100 0.0003
10 0.0371 nan 0.0100 0.0001
20 0.0322 nan 0.0100 0.0003
40 0.0241 nan 0.0100 0.0002
60 0.0184 nan 0.0100 0.0001
80 0.0143 nan 0.0100 0.0002
100 0.0115 nan 0.0100 0.0000
120 0.0092 nan 0.0100 0.0001
140 0.0074 nan 0.0100 0.0001
160 0.0058 nan 0.0100 0.0000
180 0.0047 nan 0.0100 0.0000
200 0.0039 nan 0.0100 0.0000
- Fold21: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold21: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0415 nan 0.0100 0.0004
2 0.0409 nan 0.0100 0.0002
3 0.0404 nan 0.0100 0.0006
4 0.0399 nan 0.0100 0.0004
5 0.0394 nan 0.0100 0.0005
6 0.0389 nan 0.0100 0.0004
7 0.0384 nan 0.0100 0.0004
8 0.0378 nan 0.0100 0.0006
9 0.0373 nan 0.0100 0.0004
10 0.0369 nan 0.0100 0.0005
20 0.0317 nan 0.0100 0.0002
40 0.0245 nan 0.0100 0.0004
60 0.0197 nan 0.0100 0.0001
80 0.0156 nan 0.0100 0.0001
100 0.0123 nan 0.0100 0.0001
120 0.0097 nan 0.0100 0.0001
140 0.0077 nan 0.0100 0.0000
160 0.0062 nan 0.0100 -0.0000
180 0.0052 nan 0.0100 0.0000
200 0.0043 nan 0.0100 0.0000
- Fold21: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold21: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0414 nan 0.0100 0.0005
2 0.0411 nan 0.0100 0.0002
3 0.0405 nan 0.0100 0.0006
4 0.0399 nan 0.0100 0.0005
5 0.0398 nan 0.0100 -0.0001
6 0.0392 nan 0.0100 0.0004
7 0.0387 nan 0.0100 0.0005
8 0.0383 nan 0.0100 0.0004
9 0.0379 nan 0.0100 0.0005
10 0.0373 nan 0.0100 0.0005
20 0.0329 nan 0.0100 0.0004
40 0.0273 nan 0.0100 0.0002
60 0.0228 nan 0.0100 0.0001
80 0.0189 nan 0.0100 0.0002
100 0.0159 nan 0.0100 0.0001
120 0.0135 nan 0.0100 0.0001
140 0.0115 nan 0.0100 0.0001
160 0.0102 nan 0.0100 0.0001
180 0.0092 nan 0.0100 0.0000
200 0.0082 nan 0.0100 -0.0000
- Fold21: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold21: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0415 nan 0.0100 0.0003
2 0.0407 nan 0.0100 0.0008
3 0.0401 nan 0.0100 0.0004
4 0.0396 nan 0.0100 0.0002
5 0.0391 nan 0.0100 0.0005
6 0.0386 nan 0.0100 0.0001
7 0.0379 nan 0.0100 0.0003
8 0.0373 nan 0.0100 0.0006
9 0.0368 nan 0.0100 0.0004
10 0.0361 nan 0.0100 0.0004
20 0.0312 nan 0.0100 0.0003
40 0.0242 nan 0.0100 0.0003
60 0.0180 nan 0.0100 0.0002
80 0.0136 nan 0.0100 0.0002
100 0.0106 nan 0.0100 0.0001
120 0.0080 nan 0.0100 0.0000
140 0.0062 nan 0.0100 0.0000
160 0.0050 nan 0.0100 0.0000
180 0.0040 nan 0.0100 0.0000
200 0.0032 nan 0.0100 -0.0000
- Fold21: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold21: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0412 nan 0.0100 0.0006
2 0.0408 nan 0.0100 0.0004
3 0.0401 nan 0.0100 0.0005
4 0.0395 nan 0.0100 0.0006
5 0.0390 nan 0.0100 0.0004
6 0.0383 nan 0.0100 0.0003
7 0.0378 nan 0.0100 0.0006
8 0.0374 nan 0.0100 0.0002
9 0.0368 nan 0.0100 0.0005
10 0.0364 nan 0.0100 0.0006
20 0.0322 nan 0.0100 0.0001
40 0.0239 nan 0.0100 0.0002
60 0.0185 nan 0.0100 0.0003
80 0.0141 nan 0.0100 0.0000
100 0.0110 nan 0.0100 0.0001
120 0.0085 nan 0.0100 0.0000
140 0.0069 nan 0.0100 0.0000
160 0.0056 nan 0.0100 0.0000
180 0.0047 nan 0.0100 -0.0000
200 0.0039 nan 0.0100 0.0000
- Fold21: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold21: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0417 nan 0.0100 -0.0000
2 0.0413 nan 0.0100 0.0001
3 0.0407 nan 0.0100 0.0005
4 0.0401 nan 0.0100 0.0004
5 0.0396 nan 0.0100 0.0005
6 0.0391 nan 0.0100 0.0004
7 0.0386 nan 0.0100 0.0005
8 0.0382 nan 0.0100 0.0004
9 0.0378 nan 0.0100 0.0004
10 0.0373 nan 0.0100 0.0005
20 0.0331 nan 0.0100 0.0003
40 0.0270 nan 0.0100 0.0000
60 0.0216 nan 0.0100 0.0001
80 0.0176 nan 0.0100 0.0001
100 0.0148 nan 0.0100 0.0001
120 0.0130 nan 0.0100 0.0001
140 0.0113 nan 0.0100 0.0000
160 0.0098 nan 0.0100 0.0000
180 0.0089 nan 0.0100 0.0000
200 0.0080 nan 0.0100 -0.0000
- Fold21: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold21: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0394 nan 0.0500 0.0024
2 0.0381 nan 0.0500 0.0007
3 0.0361 nan 0.0500 0.0007
4 0.0335 nan 0.0500 0.0012
5 0.0317 nan 0.0500 0.0018
6 0.0301 nan 0.0500 0.0002
7 0.0283 nan 0.0500 0.0007
8 0.0266 nan 0.0500 0.0018
9 0.0261 nan 0.0500 0.0003
10 0.0246 nan 0.0500 0.0012
20 0.0144 nan 0.0500 0.0008
40 0.0067 nan 0.0500 0.0003
60 0.0036 nan 0.0500 -0.0002
80 0.0020 nan 0.0500 0.0000
100 0.0012 nan 0.0500 -0.0000
120 0.0007 nan 0.0500 -0.0000
140 0.0004 nan 0.0500 0.0000
160 0.0002 nan 0.0500 0.0000
180 0.0002 nan 0.0500 0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold21: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold21: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0398 nan 0.0500 0.0011
2 0.0376 nan 0.0500 0.0016
3 0.0355 nan 0.0500 0.0023
4 0.0334 nan 0.0500 0.0019
5 0.0322 nan 0.0500 0.0007
6 0.0301 nan 0.0500 0.0014
7 0.0278 nan 0.0500 0.0021
8 0.0262 nan 0.0500 0.0015
9 0.0252 nan 0.0500 0.0010
10 0.0245 nan 0.0500 0.0004
20 0.0142 nan 0.0500 0.0007
40 0.0060 nan 0.0500 0.0001
60 0.0031 nan 0.0500 0.0001
80 0.0019 nan 0.0500 0.0000
100 0.0013 nan 0.0500 0.0000
120 0.0010 nan 0.0500 -0.0000
140 0.0006 nan 0.0500 -0.0000
160 0.0004 nan 0.0500 -0.0000
180 0.0003 nan 0.0500 0.0000
200 0.0002 nan 0.0500 -0.0000
- Fold21: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold21: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0393 nan 0.0500 0.0027
2 0.0373 nan 0.0500 0.0021
3 0.0355 nan 0.0500 0.0017
4 0.0331 nan 0.0500 0.0020
5 0.0311 nan 0.0500 0.0011
6 0.0291 nan 0.0500 0.0015
7 0.0279 nan 0.0500 0.0010
8 0.0268 nan 0.0500 0.0002
9 0.0254 nan 0.0500 0.0014
10 0.0238 nan 0.0500 0.0014
20 0.0160 nan 0.0500 0.0003
40 0.0086 nan 0.0500 -0.0001
60 0.0055 nan 0.0500 0.0001
80 0.0039 nan 0.0500 -0.0000
100 0.0026 nan 0.0500 -0.0000
120 0.0020 nan 0.0500 -0.0000
140 0.0014 nan 0.0500 -0.0000
160 0.0011 nan 0.0500 -0.0000
180 0.0008 nan 0.0500 -0.0000
200 0.0006 nan 0.0500 0.0000
- Fold21: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold21: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0385 nan 0.0500 0.0028
2 0.0356 nan 0.0500 0.0028
3 0.0322 nan 0.0500 0.0026
4 0.0299 nan 0.0500 0.0023
5 0.0281 nan 0.0500 0.0005
6 0.0263 nan 0.0500 0.0012
7 0.0240 nan 0.0500 0.0013
8 0.0229 nan 0.0500 0.0001
9 0.0219 nan 0.0500 0.0005
10 0.0201 nan 0.0500 0.0011
20 0.0090 nan 0.0500 0.0003
40 0.0030 nan 0.0500 0.0001
60 0.0012 nan 0.0500 0.0000
80 0.0005 nan 0.0500 -0.0000
100 0.0003 nan 0.0500 -0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0001 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 0.0000
- Fold21: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold21: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0390 nan 0.0500 0.0014
2 0.0367 nan 0.0500 0.0024
3 0.0347 nan 0.0500 0.0016
4 0.0318 nan 0.0500 0.0017
5 0.0295 nan 0.0500 0.0020
6 0.0274 nan 0.0500 0.0014
7 0.0255 nan 0.0500 0.0022
8 0.0246 nan 0.0500 0.0001
9 0.0229 nan 0.0500 0.0016
10 0.0216 nan 0.0500 0.0015
20 0.0125 nan 0.0500 0.0005
40 0.0050 nan 0.0500 0.0000
60 0.0026 nan 0.0500 -0.0001
80 0.0012 nan 0.0500 0.0000
100 0.0007 nan 0.0500 -0.0000
120 0.0004 nan 0.0500 -0.0000
140 0.0003 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold21: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold21: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0392 nan 0.0500 0.0026
2 0.0375 nan 0.0500 0.0020
3 0.0356 nan 0.0500 0.0013
4 0.0342 nan 0.0500 0.0001
5 0.0324 nan 0.0500 0.0017
6 0.0309 nan 0.0500 0.0009
7 0.0289 nan 0.0500 0.0014
8 0.0276 nan 0.0500 0.0016
9 0.0263 nan 0.0500 0.0016
10 0.0250 nan 0.0500 0.0014
20 0.0152 nan 0.0500 0.0006
40 0.0075 nan 0.0500 0.0002
60 0.0049 nan 0.0500 0.0000
80 0.0038 nan 0.0500 -0.0001
100 0.0028 nan 0.0500 0.0000
120 0.0022 nan 0.0500 0.0000
140 0.0016 nan 0.0500 0.0000
160 0.0012 nan 0.0500 -0.0000
180 0.0009 nan 0.0500 -0.0000
200 0.0007 nan 0.0500 -0.0000
- Fold21: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold21: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0397 nan 0.0500 0.0013
2 0.0359 nan 0.0500 0.0035
3 0.0338 nan 0.0500 0.0007
4 0.0308 nan 0.0500 0.0021
5 0.0283 nan 0.0500 0.0022
6 0.0267 nan 0.0500 0.0014
7 0.0247 nan 0.0500 0.0012
8 0.0226 nan 0.0500 0.0015
9 0.0213 nan 0.0500 0.0005
10 0.0195 nan 0.0500 0.0018
20 0.0095 nan 0.0500 0.0004
40 0.0031 nan 0.0500 0.0001
60 0.0011 nan 0.0500 0.0000
80 0.0004 nan 0.0500 -0.0000
100 0.0002 nan 0.0500 -0.0000
120 0.0001 nan 0.0500 0.0000
140 0.0000 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 0.0000
- Fold21: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold21: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0382 nan 0.0500 0.0023
2 0.0364 nan 0.0500 0.0007
3 0.0339 nan 0.0500 0.0016
4 0.0315 nan 0.0500 0.0010
5 0.0298 nan 0.0500 0.0010
6 0.0273 nan 0.0500 0.0011
7 0.0253 nan 0.0500 0.0017
8 0.0234 nan 0.0500 0.0020
9 0.0216 nan 0.0500 0.0017
10 0.0202 nan 0.0500 0.0013
20 0.0107 nan 0.0500 0.0006
40 0.0036 nan 0.0500 0.0001
60 0.0016 nan 0.0500 -0.0000
80 0.0008 nan 0.0500 -0.0000
100 0.0005 nan 0.0500 -0.0000
120 0.0003 nan 0.0500 -0.0000
140 0.0002 nan 0.0500 0.0000
160 0.0001 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 0.0000
- Fold21: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold21: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0394 nan 0.0500 0.0020
2 0.0373 nan 0.0500 0.0023
3 0.0349 nan 0.0500 0.0025
4 0.0326 nan 0.0500 0.0022
5 0.0308 nan 0.0500 0.0013
6 0.0288 nan 0.0500 0.0012
7 0.0266 nan 0.0500 0.0013
8 0.0254 nan 0.0500 0.0014
9 0.0240 nan 0.0500 0.0013
10 0.0227 nan 0.0500 0.0013
20 0.0142 nan 0.0500 0.0007
40 0.0073 nan 0.0500 0.0001
60 0.0041 nan 0.0500 -0.0001
80 0.0025 nan 0.0500 0.0000
100 0.0018 nan 0.0500 0.0000
120 0.0012 nan 0.0500 0.0000
140 0.0008 nan 0.0500 -0.0000
160 0.0007 nan 0.0500 -0.0000
180 0.0005 nan 0.0500 -0.0000
200 0.0003 nan 0.0500 -0.0000
- Fold21: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold21: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0385 nan 0.1000 0.0032
2 0.0333 nan 0.1000 0.0046
3 0.0307 nan 0.1000 0.0006
4 0.0288 nan 0.1000 0.0015
5 0.0277 nan 0.1000 0.0000
6 0.0242 nan 0.1000 0.0029
7 0.0219 nan 0.1000 0.0023
8 0.0188 nan 0.1000 0.0017
9 0.0166 nan 0.1000 0.0000
10 0.0149 nan 0.1000 0.0009
20 0.0080 nan 0.1000 0.0007
40 0.0024 nan 0.1000 -0.0002
60 0.0010 nan 0.1000 0.0000
80 0.0003 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold21: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold21: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0395 nan 0.1000 0.0006
2 0.0349 nan 0.1000 0.0053
3 0.0306 nan 0.1000 0.0006
4 0.0269 nan 0.1000 0.0021
5 0.0244 nan 0.1000 0.0013
6 0.0214 nan 0.1000 0.0027
7 0.0187 nan 0.1000 0.0008
8 0.0173 nan 0.1000 0.0012
9 0.0151 nan 0.1000 0.0013
10 0.0138 nan 0.1000 0.0016
20 0.0054 nan 0.1000 0.0004
40 0.0017 nan 0.1000 -0.0000
60 0.0007 nan 0.1000 0.0000
80 0.0003 nan 0.1000 -0.0000
100 0.0002 nan 0.1000 0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold21: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold21: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0366 nan 0.1000 0.0044
2 0.0325 nan 0.1000 0.0035
3 0.0289 nan 0.1000 0.0029
4 0.0273 nan 0.1000 0.0004
5 0.0236 nan 0.1000 0.0011
6 0.0210 nan 0.1000 0.0020
7 0.0184 nan 0.1000 0.0018
8 0.0170 nan 0.1000 0.0011
9 0.0149 nan 0.1000 0.0016
10 0.0143 nan 0.1000 -0.0004
20 0.0081 nan 0.1000 -0.0000
40 0.0037 nan 0.1000 -0.0002
60 0.0019 nan 0.1000 -0.0000
80 0.0010 nan 0.1000 -0.0001
100 0.0005 nan 0.1000 -0.0000
120 0.0003 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 0.0000
- Fold21: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold21: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0357 nan 0.1000 0.0055
2 0.0300 nan 0.1000 0.0044
3 0.0255 nan 0.1000 0.0041
4 0.0235 nan 0.1000 0.0013
5 0.0225 nan 0.1000 -0.0003
6 0.0191 nan 0.1000 0.0011
7 0.0167 nan 0.1000 0.0007
8 0.0152 nan 0.1000 -0.0000
9 0.0133 nan 0.1000 0.0018
10 0.0122 nan 0.1000 0.0000
20 0.0048 nan 0.1000 0.0001
40 0.0007 nan 0.1000 0.0000
60 0.0002 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold21: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold21: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0363 nan 0.1000 0.0027
2 0.0318 nan 0.1000 0.0044
3 0.0274 nan 0.1000 0.0013
4 0.0247 nan 0.1000 0.0022
5 0.0224 nan 0.1000 0.0013
6 0.0187 nan 0.1000 0.0020
7 0.0175 nan 0.1000 0.0003
8 0.0151 nan 0.1000 0.0011
9 0.0126 nan 0.1000 0.0013
10 0.0114 nan 0.1000 -0.0000
20 0.0049 nan 0.1000 -0.0000
40 0.0015 nan 0.1000 -0.0001
60 0.0007 nan 0.1000 0.0000
80 0.0003 nan 0.1000 -0.0000
100 0.0002 nan 0.1000 -0.0000
120 0.0001 nan 0.1000 0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold21: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold21: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0373 nan 0.1000 0.0038
2 0.0325 nan 0.1000 0.0039
3 0.0277 nan 0.1000 0.0036
4 0.0255 nan 0.1000 0.0013
5 0.0227 nan 0.1000 0.0006
6 0.0199 nan 0.1000 0.0019
7 0.0178 nan 0.1000 0.0017
8 0.0158 nan 0.1000 0.0016
9 0.0141 nan 0.1000 0.0015
10 0.0125 nan 0.1000 0.0006
20 0.0063 nan 0.1000 -0.0000
40 0.0033 nan 0.1000 -0.0001
60 0.0014 nan 0.1000 -0.0001
80 0.0007 nan 0.1000 -0.0000
100 0.0004 nan 0.1000 0.0000
120 0.0002 nan 0.1000 0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold21: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold21: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0360 nan 0.1000 0.0035
2 0.0301 nan 0.1000 0.0034
3 0.0251 nan 0.1000 0.0041
4 0.0208 nan 0.1000 0.0039
5 0.0178 nan 0.1000 0.0027
6 0.0168 nan 0.1000 -0.0007
7 0.0146 nan 0.1000 0.0009
8 0.0134 nan 0.1000 0.0006
9 0.0125 nan 0.1000 -0.0001
10 0.0108 nan 0.1000 0.0007
20 0.0031 nan 0.1000 0.0001
40 0.0005 nan 0.1000 -0.0000
60 0.0001 nan 0.1000 -0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold21: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold21: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0359 nan 0.1000 0.0023
2 0.0306 nan 0.1000 0.0062
3 0.0258 nan 0.1000 0.0027
4 0.0217 nan 0.1000 0.0029
5 0.0193 nan 0.1000 0.0019
6 0.0169 nan 0.1000 0.0015
7 0.0142 nan 0.1000 0.0013
8 0.0127 nan 0.1000 0.0006
9 0.0129 nan 0.1000 -0.0012
10 0.0113 nan 0.1000 0.0016
20 0.0043 nan 0.1000 0.0002
40 0.0011 nan 0.1000 0.0000
60 0.0005 nan 0.1000 0.0000
80 0.0002 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold21: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold21: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0357 nan 0.1000 0.0046
2 0.0328 nan 0.1000 0.0019
3 0.0304 nan 0.1000 0.0025
4 0.0268 nan 0.1000 0.0032
5 0.0243 nan 0.1000 0.0012
6 0.0235 nan 0.1000 0.0002
7 0.0213 nan 0.1000 0.0024
8 0.0196 nan 0.1000 0.0014
9 0.0181 nan 0.1000 0.0006
10 0.0169 nan 0.1000 0.0012
20 0.0071 nan 0.1000 0.0003
40 0.0028 nan 0.1000 -0.0000
60 0.0013 nan 0.1000 0.0000
80 0.0007 nan 0.1000 -0.0000
100 0.0004 nan 0.1000 0.0000
120 0.0002 nan 0.1000 0.0000
140 0.0001 nan 0.1000 0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold21: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold22: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0414 nan 0.0100 0.0002
2 0.0409 nan 0.0100 0.0004
3 0.0404 nan 0.0100 0.0005
4 0.0399 nan 0.0100 0.0004
5 0.0395 nan 0.0100 0.0003
6 0.0390 nan 0.0100 0.0005
7 0.0386 nan 0.0100 0.0002
8 0.0380 nan 0.0100 0.0005
9 0.0374 nan 0.0100 0.0005
10 0.0369 nan 0.0100 0.0004
20 0.0330 nan 0.0100 0.0002
40 0.0273 nan 0.0100 0.0002
60 0.0222 nan 0.0100 0.0000
80 0.0183 nan 0.0100 -0.0000
100 0.0147 nan 0.0100 0.0001
120 0.0123 nan 0.0100 0.0001
140 0.0105 nan 0.0100 0.0001
160 0.0089 nan 0.0100 0.0000
180 0.0075 nan 0.0100 0.0000
200 0.0063 nan 0.0100 0.0001
- Fold22: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold22: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0412 nan 0.0100 0.0006
2 0.0407 nan 0.0100 0.0003
3 0.0401 nan 0.0100 0.0005
4 0.0397 nan 0.0100 0.0004
5 0.0392 nan 0.0100 0.0004
6 0.0389 nan 0.0100 0.0001
7 0.0383 nan 0.0100 0.0005
8 0.0378 nan 0.0100 0.0005
9 0.0374 nan 0.0100 0.0002
10 0.0368 nan 0.0100 0.0003
20 0.0331 nan 0.0100 0.0003
40 0.0262 nan 0.0100 0.0003
60 0.0213 nan 0.0100 0.0001
80 0.0176 nan 0.0100 0.0000
100 0.0147 nan 0.0100 0.0001
120 0.0123 nan 0.0100 0.0001
140 0.0104 nan 0.0100 0.0000
160 0.0090 nan 0.0100 0.0000
180 0.0078 nan 0.0100 -0.0000
200 0.0068 nan 0.0100 0.0000
- Fold22: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold22: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0411 nan 0.0100 0.0005
2 0.0405 nan 0.0100 0.0005
3 0.0400 nan 0.0100 0.0004
4 0.0395 nan 0.0100 0.0003
5 0.0392 nan 0.0100 0.0001
6 0.0386 nan 0.0100 0.0005
7 0.0381 nan 0.0100 0.0003
8 0.0376 nan 0.0100 0.0005
9 0.0372 nan 0.0100 0.0001
10 0.0367 nan 0.0100 0.0005
20 0.0332 nan 0.0100 -0.0002
40 0.0266 nan 0.0100 0.0003
60 0.0218 nan 0.0100 0.0003
80 0.0180 nan 0.0100 -0.0001
100 0.0153 nan 0.0100 0.0001
120 0.0131 nan 0.0100 0.0000
140 0.0114 nan 0.0100 0.0001
160 0.0098 nan 0.0100 0.0001
180 0.0088 nan 0.0100 0.0000
200 0.0079 nan 0.0100 0.0000
- Fold22: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold22: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0411 nan 0.0100 0.0005
2 0.0406 nan 0.0100 0.0004
3 0.0399 nan 0.0100 0.0007
4 0.0395 nan 0.0100 0.0005
5 0.0389 nan 0.0100 0.0002
6 0.0383 nan 0.0100 0.0002
7 0.0381 nan 0.0100 0.0000
8 0.0375 nan 0.0100 0.0004
9 0.0370 nan 0.0100 0.0001
10 0.0363 nan 0.0100 0.0006
20 0.0318 nan 0.0100 0.0002
40 0.0241 nan 0.0100 0.0002
60 0.0184 nan 0.0100 -0.0001
80 0.0145 nan 0.0100 0.0000
100 0.0116 nan 0.0100 0.0000
120 0.0093 nan 0.0100 0.0000
140 0.0076 nan 0.0100 0.0001
160 0.0062 nan 0.0100 0.0000
180 0.0050 nan 0.0100 -0.0000
200 0.0042 nan 0.0100 0.0000
- Fold22: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold22: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0411 nan 0.0100 0.0003
2 0.0406 nan 0.0100 0.0002
3 0.0399 nan 0.0100 0.0007
4 0.0393 nan 0.0100 0.0004
5 0.0388 nan 0.0100 0.0004
6 0.0385 nan 0.0100 0.0002
7 0.0379 nan 0.0100 0.0004
8 0.0374 nan 0.0100 0.0003
9 0.0370 nan 0.0100 0.0003
10 0.0365 nan 0.0100 0.0005
20 0.0323 nan 0.0100 0.0004
40 0.0244 nan 0.0100 0.0002
60 0.0189 nan 0.0100 0.0002
80 0.0149 nan 0.0100 0.0001
100 0.0121 nan 0.0100 0.0001
120 0.0097 nan 0.0100 0.0001
140 0.0078 nan 0.0100 -0.0000
160 0.0066 nan 0.0100 -0.0000
180 0.0055 nan 0.0100 -0.0000
200 0.0047 nan 0.0100 -0.0000
- Fold22: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold22: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0414 nan 0.0100 0.0001
2 0.0408 nan 0.0100 0.0005
3 0.0402 nan 0.0100 0.0006
4 0.0398 nan 0.0100 0.0003
5 0.0394 nan 0.0100 0.0002
6 0.0388 nan 0.0100 0.0002
7 0.0384 nan 0.0100 0.0003
8 0.0380 nan 0.0100 0.0004
9 0.0374 nan 0.0100 0.0004
10 0.0368 nan 0.0100 0.0003
20 0.0328 nan 0.0100 0.0004
40 0.0264 nan 0.0100 0.0001
60 0.0219 nan 0.0100 0.0002
80 0.0180 nan 0.0100 0.0001
100 0.0156 nan 0.0100 0.0000
120 0.0131 nan 0.0100 0.0000
140 0.0115 nan 0.0100 0.0001
160 0.0101 nan 0.0100 0.0000
180 0.0089 nan 0.0100 0.0001
200 0.0079 nan 0.0100 0.0000
- Fold22: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold22: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0413 nan 0.0100 0.0002
2 0.0405 nan 0.0100 0.0006
3 0.0398 nan 0.0100 0.0005
4 0.0392 nan 0.0100 0.0006
5 0.0385 nan 0.0100 0.0006
6 0.0380 nan 0.0100 0.0003
7 0.0373 nan 0.0100 0.0004
8 0.0370 nan 0.0100 0.0002
9 0.0366 nan 0.0100 0.0001
10 0.0362 nan 0.0100 0.0003
20 0.0310 nan 0.0100 0.0002
40 0.0235 nan 0.0100 0.0002
60 0.0176 nan 0.0100 0.0003
80 0.0137 nan 0.0100 0.0001
100 0.0108 nan 0.0100 0.0001
120 0.0085 nan 0.0100 0.0000
140 0.0067 nan 0.0100 0.0000
160 0.0053 nan 0.0100 0.0000
180 0.0042 nan 0.0100 0.0000
200 0.0034 nan 0.0100 -0.0000
- Fold22: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold22: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0412 nan 0.0100 0.0005
2 0.0406 nan 0.0100 0.0006
3 0.0400 nan 0.0100 0.0005
4 0.0395 nan 0.0100 0.0004
5 0.0390 nan 0.0100 0.0002
6 0.0386 nan 0.0100 0.0002
7 0.0379 nan 0.0100 0.0007
8 0.0374 nan 0.0100 0.0004
9 0.0370 nan 0.0100 0.0002
10 0.0365 nan 0.0100 0.0004
20 0.0319 nan 0.0100 0.0003
40 0.0245 nan 0.0100 0.0004
60 0.0192 nan 0.0100 0.0002
80 0.0154 nan 0.0100 0.0001
100 0.0120 nan 0.0100 0.0000
120 0.0094 nan 0.0100 0.0001
140 0.0076 nan 0.0100 0.0000
160 0.0064 nan 0.0100 0.0000
180 0.0052 nan 0.0100 0.0000
200 0.0043 nan 0.0100 -0.0000
- Fold22: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold22: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0411 nan 0.0100 0.0006
2 0.0406 nan 0.0100 0.0002
3 0.0400 nan 0.0100 0.0005
4 0.0395 nan 0.0100 0.0005
5 0.0391 nan 0.0100 0.0004
6 0.0387 nan 0.0100 0.0003
7 0.0381 nan 0.0100 0.0005
8 0.0377 nan 0.0100 0.0003
9 0.0374 nan 0.0100 0.0002
10 0.0371 nan 0.0100 0.0004
20 0.0331 nan 0.0100 0.0000
40 0.0267 nan 0.0100 0.0001
60 0.0216 nan 0.0100 0.0002
80 0.0183 nan 0.0100 0.0001
100 0.0156 nan 0.0100 0.0001
120 0.0136 nan 0.0100 0.0001
140 0.0119 nan 0.0100 0.0000
160 0.0101 nan 0.0100 0.0001
180 0.0090 nan 0.0100 0.0000
200 0.0080 nan 0.0100 -0.0000
- Fold22: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold22: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0389 nan 0.0500 0.0027
2 0.0366 nan 0.0500 0.0023
3 0.0364 nan 0.0500 -0.0003
4 0.0338 nan 0.0500 0.0012
5 0.0321 nan 0.0500 0.0015
6 0.0307 nan 0.0500 0.0007
7 0.0286 nan 0.0500 0.0021
8 0.0269 nan 0.0500 0.0013
9 0.0256 nan 0.0500 0.0014
10 0.0242 nan 0.0500 0.0013
20 0.0159 nan 0.0500 0.0004
40 0.0067 nan 0.0500 0.0000
60 0.0030 nan 0.0500 -0.0000
80 0.0017 nan 0.0500 -0.0000
100 0.0010 nan 0.0500 0.0000
120 0.0006 nan 0.0500 0.0000
140 0.0004 nan 0.0500 -0.0000
160 0.0003 nan 0.0500 -0.0000
180 0.0002 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold22: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold22: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0388 nan 0.0500 0.0027
2 0.0360 nan 0.0500 0.0022
3 0.0335 nan 0.0500 0.0022
4 0.0316 nan 0.0500 0.0017
5 0.0296 nan 0.0500 0.0018
6 0.0277 nan 0.0500 0.0019
7 0.0264 nan 0.0500 0.0014
8 0.0253 nan 0.0500 0.0003
9 0.0236 nan 0.0500 0.0011
10 0.0224 nan 0.0500 0.0007
20 0.0137 nan 0.0500 -0.0008
40 0.0053 nan 0.0500 -0.0001
60 0.0027 nan 0.0500 0.0001
80 0.0015 nan 0.0500 0.0000
100 0.0010 nan 0.0500 -0.0000
120 0.0006 nan 0.0500 -0.0000
140 0.0004 nan 0.0500 -0.0000
160 0.0003 nan 0.0500 -0.0000
180 0.0002 nan 0.0500 0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold22: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold22: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0409 nan 0.0500 -0.0015
2 0.0391 nan 0.0500 0.0008
3 0.0374 nan 0.0500 0.0009
4 0.0351 nan 0.0500 0.0021
5 0.0330 nan 0.0500 0.0023
6 0.0313 nan 0.0500 0.0009
7 0.0295 nan 0.0500 0.0013
8 0.0286 nan 0.0500 0.0002
9 0.0278 nan 0.0500 0.0004
10 0.0271 nan 0.0500 0.0001
20 0.0179 nan 0.0500 0.0002
40 0.0089 nan 0.0500 0.0001
60 0.0058 nan 0.0500 0.0002
80 0.0038 nan 0.0500 0.0000
100 0.0025 nan 0.0500 -0.0000
120 0.0017 nan 0.0500 0.0000
140 0.0012 nan 0.0500 -0.0000
160 0.0009 nan 0.0500 -0.0000
180 0.0006 nan 0.0500 0.0000
200 0.0005 nan 0.0500 -0.0000
- Fold22: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold22: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0385 nan 0.0500 0.0027
2 0.0363 nan 0.0500 0.0020
3 0.0335 nan 0.0500 0.0025
4 0.0314 nan 0.0500 0.0018
5 0.0294 nan 0.0500 0.0014
6 0.0283 nan 0.0500 0.0007
7 0.0266 nan 0.0500 0.0014
8 0.0251 nan 0.0500 0.0012
9 0.0235 nan 0.0500 0.0013
10 0.0220 nan 0.0500 0.0011
20 0.0125 nan 0.0500 -0.0005
40 0.0035 nan 0.0500 0.0000
60 0.0015 nan 0.0500 -0.0000
80 0.0007 nan 0.0500 -0.0000
100 0.0003 nan 0.0500 -0.0000
120 0.0002 nan 0.0500 0.0000
140 0.0001 nan 0.0500 -0.0000
160 0.0001 nan 0.0500 0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold22: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold22: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0385 nan 0.0500 0.0026
2 0.0363 nan 0.0500 0.0026
3 0.0344 nan 0.0500 0.0012
4 0.0321 nan 0.0500 0.0026
5 0.0294 nan 0.0500 0.0018
6 0.0276 nan 0.0500 0.0015
7 0.0254 nan 0.0500 0.0013
8 0.0233 nan 0.0500 0.0007
9 0.0215 nan 0.0500 0.0009
10 0.0207 nan 0.0500 0.0004
20 0.0121 nan 0.0500 0.0005
40 0.0048 nan 0.0500 0.0000
60 0.0023 nan 0.0500 -0.0000
80 0.0013 nan 0.0500 0.0000
100 0.0008 nan 0.0500 -0.0000
120 0.0004 nan 0.0500 0.0000
140 0.0002 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold22: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold22: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0386 nan 0.0500 0.0025
2 0.0361 nan 0.0500 0.0023
3 0.0334 nan 0.0500 0.0024
4 0.0318 nan 0.0500 0.0016
5 0.0301 nan 0.0500 0.0005
6 0.0289 nan 0.0500 0.0013
7 0.0276 nan 0.0500 0.0010
8 0.0265 nan 0.0500 0.0006
9 0.0260 nan 0.0500 0.0002
10 0.0243 nan 0.0500 0.0011
20 0.0173 nan 0.0500 0.0004
40 0.0105 nan 0.0500 0.0004
60 0.0060 nan 0.0500 0.0001
80 0.0041 nan 0.0500 0.0000
100 0.0031 nan 0.0500 0.0000
120 0.0023 nan 0.0500 0.0000
140 0.0016 nan 0.0500 -0.0000
160 0.0013 nan 0.0500 -0.0000
180 0.0011 nan 0.0500 -0.0000
200 0.0008 nan 0.0500 0.0000
- Fold22: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold22: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0396 nan 0.0500 0.0001
2 0.0375 nan 0.0500 0.0013
3 0.0346 nan 0.0500 0.0024
4 0.0314 nan 0.0500 0.0022
5 0.0292 nan 0.0500 0.0022
6 0.0270 nan 0.0500 0.0019
7 0.0252 nan 0.0500 0.0008
8 0.0233 nan 0.0500 0.0019
9 0.0218 nan 0.0500 0.0011
10 0.0204 nan 0.0500 0.0007
20 0.0109 nan 0.0500 0.0006
40 0.0033 nan 0.0500 -0.0000
60 0.0012 nan 0.0500 0.0001
80 0.0006 nan 0.0500 -0.0000
100 0.0003 nan 0.0500 0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0001 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 0.0000
- Fold22: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold22: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0389 nan 0.0500 0.0027
2 0.0362 nan 0.0500 0.0017
3 0.0342 nan 0.0500 0.0020
4 0.0327 nan 0.0500 0.0013
5 0.0299 nan 0.0500 0.0018
6 0.0281 nan 0.0500 0.0014
7 0.0257 nan 0.0500 0.0022
8 0.0243 nan 0.0500 0.0010
9 0.0229 nan 0.0500 0.0010
10 0.0216 nan 0.0500 0.0009
20 0.0119 nan 0.0500 0.0002
40 0.0045 nan 0.0500 -0.0000
60 0.0019 nan 0.0500 -0.0000
80 0.0010 nan 0.0500 0.0000
100 0.0006 nan 0.0500 0.0000
120 0.0003 nan 0.0500 -0.0000
140 0.0002 nan 0.0500 -0.0000
160 0.0001 nan 0.0500 0.0000
180 0.0001 nan 0.0500 0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold22: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold22: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0395 nan 0.0500 -0.0001
2 0.0370 nan 0.0500 0.0018
3 0.0347 nan 0.0500 0.0019
4 0.0328 nan 0.0500 0.0021
5 0.0307 nan 0.0500 0.0021
6 0.0285 nan 0.0500 0.0017
7 0.0264 nan 0.0500 0.0017
8 0.0251 nan 0.0500 -0.0005
9 0.0242 nan 0.0500 0.0012
10 0.0225 nan 0.0500 0.0013
20 0.0145 nan 0.0500 0.0005
40 0.0073 nan 0.0500 -0.0001
60 0.0045 nan 0.0500 0.0000
80 0.0030 nan 0.0500 -0.0001
100 0.0020 nan 0.0500 -0.0000
120 0.0013 nan 0.0500 -0.0000
140 0.0010 nan 0.0500 -0.0000
160 0.0008 nan 0.0500 -0.0000
180 0.0006 nan 0.0500 -0.0000
200 0.0004 nan 0.0500 0.0000
- Fold22: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold22: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0364 nan 0.1000 0.0048
2 0.0345 nan 0.1000 -0.0011
3 0.0312 nan 0.1000 0.0026
4 0.0289 nan 0.1000 0.0000
5 0.0262 nan 0.1000 0.0013
6 0.0242 nan 0.1000 0.0003
7 0.0218 nan 0.1000 0.0017
8 0.0201 nan 0.1000 0.0010
9 0.0177 nan 0.1000 0.0022
10 0.0163 nan 0.1000 0.0007
20 0.0064 nan 0.1000 -0.0000
40 0.0019 nan 0.1000 0.0001
60 0.0006 nan 0.1000 -0.0000
80 0.0002 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 0.0000
120 0.0000 nan 0.1000 0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold22: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold22: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0363 nan 0.1000 0.0023
2 0.0319 nan 0.1000 0.0041
3 0.0288 nan 0.1000 0.0025
4 0.0277 nan 0.1000 0.0000
5 0.0240 nan 0.1000 0.0026
6 0.0209 nan 0.1000 0.0022
7 0.0185 nan 0.1000 0.0012
8 0.0178 nan 0.1000 -0.0003
9 0.0169 nan 0.1000 0.0001
10 0.0151 nan 0.1000 0.0001
20 0.0073 nan 0.1000 0.0001
40 0.0023 nan 0.1000 -0.0000
60 0.0008 nan 0.1000 -0.0000
80 0.0004 nan 0.1000 -0.0000
100 0.0002 nan 0.1000 -0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold22: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold22: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0366 nan 0.1000 0.0050
2 0.0332 nan 0.1000 0.0027
3 0.0299 nan 0.1000 0.0037
4 0.0269 nan 0.1000 0.0034
5 0.0241 nan 0.1000 0.0029
6 0.0220 nan 0.1000 0.0010
7 0.0198 nan 0.1000 -0.0003
8 0.0178 nan 0.1000 0.0013
9 0.0168 nan 0.1000 0.0002
10 0.0148 nan 0.1000 0.0010
20 0.0075 nan 0.1000 0.0001
40 0.0022 nan 0.1000 0.0000
60 0.0010 nan 0.1000 -0.0001
80 0.0005 nan 0.1000 0.0000
100 0.0003 nan 0.1000 -0.0000
120 0.0002 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 0.0000
200 0.0000 nan 0.1000 0.0000
- Fold22: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold22: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0338 nan 0.1000 0.0084
2 0.0277 nan 0.1000 0.0038
3 0.0245 nan 0.1000 0.0010
4 0.0211 nan 0.1000 0.0037
5 0.0193 nan 0.1000 0.0010
6 0.0165 nan 0.1000 0.0015
7 0.0139 nan 0.1000 0.0026
8 0.0127 nan 0.1000 0.0011
9 0.0114 nan 0.1000 0.0012
10 0.0101 nan 0.1000 0.0009
20 0.0040 nan 0.1000 0.0003
40 0.0007 nan 0.1000 0.0000
60 0.0003 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold22: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold22: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0366 nan 0.1000 0.0044
2 0.0315 nan 0.1000 0.0043
3 0.0259 nan 0.1000 0.0034
4 0.0238 nan 0.1000 0.0010
5 0.0215 nan 0.1000 -0.0002
6 0.0188 nan 0.1000 -0.0000
7 0.0157 nan 0.1000 0.0017
8 0.0135 nan 0.1000 0.0016
9 0.0131 nan 0.1000 0.0003
10 0.0121 nan 0.1000 -0.0001
20 0.0041 nan 0.1000 0.0001
40 0.0009 nan 0.1000 0.0000
60 0.0004 nan 0.1000 -0.0000
80 0.0002 nan 0.1000 0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0001 nan 0.1000 0.0000
140 0.0000 nan 0.1000 0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold22: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold22: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0365 nan 0.1000 0.0049
2 0.0328 nan 0.1000 0.0028
3 0.0295 nan 0.1000 0.0016
4 0.0262 nan 0.1000 0.0034
5 0.0235 nan 0.1000 0.0024
6 0.0225 nan 0.1000 -0.0005
7 0.0203 nan 0.1000 0.0016
8 0.0182 nan 0.1000 0.0014
9 0.0163 nan 0.1000 0.0001
10 0.0154 nan 0.1000 -0.0003
20 0.0076 nan 0.1000 0.0003
40 0.0033 nan 0.1000 -0.0001
60 0.0014 nan 0.1000 -0.0001
80 0.0008 nan 0.1000 0.0000
100 0.0004 nan 0.1000 -0.0000
120 0.0002 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold22: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold22: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0364 nan 0.1000 0.0029
2 0.0321 nan 0.1000 0.0031
3 0.0262 nan 0.1000 0.0051
4 0.0239 nan 0.1000 -0.0001
5 0.0199 nan 0.1000 0.0023
6 0.0171 nan 0.1000 0.0018
7 0.0146 nan 0.1000 0.0011
8 0.0128 nan 0.1000 0.0004
9 0.0113 nan 0.1000 0.0009
10 0.0098 nan 0.1000 0.0015
20 0.0033 nan 0.1000 -0.0002
40 0.0006 nan 0.1000 -0.0000
60 0.0001 nan 0.1000 -0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold22: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold22: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0347 nan 0.1000 0.0057
2 0.0295 nan 0.1000 0.0044
3 0.0262 nan 0.1000 0.0029
4 0.0241 nan 0.1000 0.0024
5 0.0216 nan 0.1000 0.0019
6 0.0196 nan 0.1000 0.0008
7 0.0169 nan 0.1000 0.0005
8 0.0156 nan 0.1000 0.0009
9 0.0137 nan 0.1000 0.0010
10 0.0126 nan 0.1000 0.0002
20 0.0043 nan 0.1000 0.0003
40 0.0014 nan 0.1000 -0.0001
60 0.0005 nan 0.1000 0.0000
80 0.0002 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold22: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold22: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0382 nan 0.1000 0.0007
2 0.0347 nan 0.1000 0.0024
3 0.0332 nan 0.1000 -0.0012
4 0.0298 nan 0.1000 0.0033
5 0.0260 nan 0.1000 0.0024
6 0.0226 nan 0.1000 0.0028
7 0.0201 nan 0.1000 0.0018
8 0.0189 nan 0.1000 0.0008
9 0.0173 nan 0.1000 0.0009
10 0.0158 nan 0.1000 0.0012
20 0.0098 nan 0.1000 0.0003
40 0.0037 nan 0.1000 -0.0001
60 0.0016 nan 0.1000 0.0000
80 0.0009 nan 0.1000 0.0000
100 0.0006 nan 0.1000 0.0000
120 0.0004 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 0.0000
160 0.0002 nan 0.1000 0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 0.0000
- Fold22: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold23: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0436 nan 0.0100 0.0005
2 0.0431 nan 0.0100 0.0004
3 0.0428 nan 0.0100 0.0001
4 0.0423 nan 0.0100 0.0003
5 0.0416 nan 0.0100 0.0005
6 0.0413 nan 0.0100 0.0003
7 0.0408 nan 0.0100 0.0005
8 0.0404 nan 0.0100 0.0005
9 0.0399 nan 0.0100 0.0005
10 0.0393 nan 0.0100 0.0005
20 0.0348 nan 0.0100 0.0004
40 0.0276 nan 0.0100 0.0004
60 0.0222 nan 0.0100 -0.0001
80 0.0183 nan 0.0100 0.0001
100 0.0149 nan 0.0100 0.0002
120 0.0125 nan 0.0100 0.0001
140 0.0102 nan 0.0100 0.0000
160 0.0086 nan 0.0100 0.0000
180 0.0071 nan 0.0100 0.0000
200 0.0060 nan 0.0100 0.0000
- Fold23: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold23: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0436 nan 0.0100 0.0006
2 0.0431 nan 0.0100 0.0006
3 0.0425 nan 0.0100 0.0005
4 0.0419 nan 0.0100 0.0006
5 0.0414 nan 0.0100 0.0004
6 0.0409 nan 0.0100 0.0005
7 0.0403 nan 0.0100 0.0005
8 0.0398 nan 0.0100 0.0005
9 0.0393 nan 0.0100 0.0004
10 0.0388 nan 0.0100 0.0003
20 0.0342 nan 0.0100 0.0004
40 0.0274 nan 0.0100 0.0003
60 0.0218 nan 0.0100 0.0001
80 0.0175 nan 0.0100 0.0001
100 0.0143 nan 0.0100 0.0001
120 0.0121 nan 0.0100 0.0001
140 0.0098 nan 0.0100 0.0001
160 0.0082 nan 0.0100 0.0001
180 0.0069 nan 0.0100 0.0001
200 0.0059 nan 0.0100 0.0000
- Fold23: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold23: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0434 nan 0.0100 0.0005
2 0.0427 nan 0.0100 0.0005
3 0.0421 nan 0.0100 0.0006
4 0.0415 nan 0.0100 0.0003
5 0.0409 nan 0.0100 0.0005
6 0.0405 nan 0.0100 0.0004
7 0.0401 nan 0.0100 0.0003
8 0.0398 nan 0.0100 0.0002
9 0.0392 nan 0.0100 0.0006
10 0.0388 nan 0.0100 0.0004
20 0.0341 nan 0.0100 0.0004
40 0.0272 nan 0.0100 0.0002
60 0.0225 nan 0.0100 0.0001
80 0.0186 nan 0.0100 0.0002
100 0.0157 nan 0.0100 0.0001
120 0.0130 nan 0.0100 -0.0000
140 0.0112 nan 0.0100 0.0000
160 0.0097 nan 0.0100 0.0000
180 0.0085 nan 0.0100 0.0000
200 0.0075 nan 0.0100 0.0000
- Fold23: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold23: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0436 nan 0.0100 0.0001
2 0.0431 nan 0.0100 0.0005
3 0.0427 nan 0.0100 0.0004
4 0.0420 nan 0.0100 0.0005
5 0.0413 nan 0.0100 0.0005
6 0.0407 nan 0.0100 0.0005
7 0.0402 nan 0.0100 0.0005
8 0.0395 nan 0.0100 0.0005
9 0.0388 nan 0.0100 0.0005
10 0.0381 nan 0.0100 0.0004
20 0.0333 nan 0.0100 0.0006
40 0.0254 nan 0.0100 0.0002
60 0.0197 nan 0.0100 0.0002
80 0.0154 nan 0.0100 0.0002
100 0.0117 nan 0.0100 0.0001
120 0.0094 nan 0.0100 0.0000
140 0.0073 nan 0.0100 0.0000
160 0.0058 nan 0.0100 0.0000
180 0.0047 nan 0.0100 0.0000
200 0.0038 nan 0.0100 0.0000
- Fold23: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold23: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0434 nan 0.0100 0.0005
2 0.0426 nan 0.0100 0.0007
3 0.0421 nan 0.0100 0.0005
4 0.0418 nan 0.0100 0.0003
5 0.0414 nan 0.0100 0.0002
6 0.0410 nan 0.0100 0.0005
7 0.0404 nan 0.0100 0.0005
8 0.0398 nan 0.0100 0.0005
9 0.0393 nan 0.0100 0.0006
10 0.0387 nan 0.0100 0.0005
20 0.0337 nan 0.0100 0.0004
40 0.0260 nan 0.0100 0.0001
60 0.0199 nan 0.0100 0.0002
80 0.0154 nan 0.0100 0.0002
100 0.0121 nan 0.0100 0.0001
120 0.0097 nan 0.0100 0.0001
140 0.0078 nan 0.0100 0.0000
160 0.0065 nan 0.0100 0.0001
180 0.0052 nan 0.0100 0.0000
200 0.0044 nan 0.0100 0.0000
- Fold23: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold23: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0436 nan 0.0100 0.0002
2 0.0430 nan 0.0100 0.0006
3 0.0425 nan 0.0100 0.0005
4 0.0421 nan 0.0100 0.0003
5 0.0416 nan 0.0100 0.0004
6 0.0410 nan 0.0100 0.0005
7 0.0406 nan 0.0100 0.0004
8 0.0401 nan 0.0100 0.0005
9 0.0397 nan 0.0100 0.0002
10 0.0392 nan 0.0100 0.0003
20 0.0346 nan 0.0100 -0.0000
40 0.0280 nan 0.0100 0.0003
60 0.0231 nan 0.0100 0.0002
80 0.0186 nan 0.0100 0.0000
100 0.0157 nan 0.0100 0.0001
120 0.0133 nan 0.0100 0.0000
140 0.0114 nan 0.0100 -0.0000
160 0.0098 nan 0.0100 0.0000
180 0.0085 nan 0.0100 0.0000
200 0.0074 nan 0.0100 0.0000
- Fold23: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold23: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0433 nan 0.0100 0.0006
2 0.0427 nan 0.0100 0.0003
3 0.0420 nan 0.0100 0.0005
4 0.0415 nan 0.0100 0.0006
5 0.0409 nan 0.0100 0.0003
6 0.0404 nan 0.0100 -0.0001
7 0.0397 nan 0.0100 0.0006
8 0.0392 nan 0.0100 -0.0000
9 0.0384 nan 0.0100 0.0006
10 0.0379 nan 0.0100 0.0003
20 0.0329 nan 0.0100 0.0006
40 0.0247 nan 0.0100 0.0002
60 0.0185 nan 0.0100 0.0001
80 0.0144 nan 0.0100 -0.0001
100 0.0111 nan 0.0100 0.0001
120 0.0086 nan 0.0100 -0.0000
140 0.0068 nan 0.0100 0.0000
160 0.0054 nan 0.0100 0.0000
180 0.0043 nan 0.0100 -0.0000
200 0.0035 nan 0.0100 -0.0000
- Fold23: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold23: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0434 nan 0.0100 0.0005
2 0.0430 nan 0.0100 0.0005
3 0.0426 nan 0.0100 0.0004
4 0.0420 nan 0.0100 0.0005
5 0.0414 nan 0.0100 0.0004
6 0.0411 nan 0.0100 -0.0003
7 0.0406 nan 0.0100 0.0005
8 0.0398 nan 0.0100 0.0005
9 0.0393 nan 0.0100 0.0006
10 0.0388 nan 0.0100 0.0005
20 0.0345 nan 0.0100 0.0002
40 0.0265 nan 0.0100 0.0004
60 0.0209 nan 0.0100 0.0002
80 0.0163 nan 0.0100 0.0002
100 0.0127 nan 0.0100 0.0000
120 0.0099 nan 0.0100 -0.0000
140 0.0081 nan 0.0100 0.0000
160 0.0066 nan 0.0100 0.0001
180 0.0053 nan 0.0100 0.0000
200 0.0044 nan 0.0100 0.0000
- Fold23: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold23: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0436 nan 0.0100 0.0003
2 0.0431 nan 0.0100 0.0005
3 0.0427 nan 0.0100 0.0001
4 0.0423 nan 0.0100 0.0004
5 0.0417 nan 0.0100 0.0004
6 0.0411 nan 0.0100 0.0002
7 0.0404 nan 0.0100 0.0005
8 0.0399 nan 0.0100 0.0005
9 0.0396 nan 0.0100 0.0003
10 0.0391 nan 0.0100 0.0003
20 0.0353 nan 0.0100 0.0003
40 0.0282 nan 0.0100 0.0001
60 0.0231 nan 0.0100 0.0001
80 0.0191 nan 0.0100 0.0001
100 0.0161 nan 0.0100 0.0001
120 0.0135 nan 0.0100 0.0001
140 0.0114 nan 0.0100 0.0001
160 0.0100 nan 0.0100 0.0000
180 0.0087 nan 0.0100 0.0000
200 0.0077 nan 0.0100 0.0000
- Fold23: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold23: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0416 nan 0.0500 0.0029
2 0.0383 nan 0.0500 0.0017
3 0.0366 nan 0.0500 0.0014
4 0.0342 nan 0.0500 0.0013
5 0.0330 nan 0.0500 0.0010
6 0.0313 nan 0.0500 0.0019
7 0.0297 nan 0.0500 0.0007
8 0.0283 nan 0.0500 0.0005
9 0.0267 nan 0.0500 0.0014
10 0.0253 nan 0.0500 0.0016
20 0.0155 nan 0.0500 0.0001
40 0.0064 nan 0.0500 0.0001
60 0.0031 nan 0.0500 0.0000
80 0.0016 nan 0.0500 0.0000
100 0.0010 nan 0.0500 -0.0000
120 0.0006 nan 0.0500 0.0000
140 0.0003 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 0.0000
180 0.0001 nan 0.0500 0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold23: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold23: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0418 nan 0.0500 0.0020
2 0.0402 nan 0.0500 0.0014
3 0.0377 nan 0.0500 0.0024
4 0.0361 nan 0.0500 0.0013
5 0.0339 nan 0.0500 0.0015
6 0.0326 nan 0.0500 0.0012
7 0.0308 nan 0.0500 0.0020
8 0.0289 nan 0.0500 0.0021
9 0.0274 nan 0.0500 0.0016
10 0.0259 nan 0.0500 0.0014
20 0.0168 nan 0.0500 -0.0002
40 0.0073 nan 0.0500 0.0004
60 0.0038 nan 0.0500 0.0000
80 0.0019 nan 0.0500 0.0000
100 0.0009 nan 0.0500 -0.0000
120 0.0006 nan 0.0500 0.0000
140 0.0004 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold23: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold23: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0426 nan 0.0500 -0.0001
2 0.0411 nan 0.0500 0.0006
3 0.0389 nan 0.0500 0.0012
4 0.0374 nan 0.0500 0.0016
5 0.0349 nan 0.0500 0.0025
6 0.0324 nan 0.0500 0.0012
7 0.0311 nan 0.0500 0.0014
8 0.0289 nan 0.0500 0.0016
9 0.0271 nan 0.0500 0.0012
10 0.0262 nan 0.0500 0.0002
20 0.0167 nan 0.0500 0.0009
40 0.0086 nan 0.0500 0.0002
60 0.0054 nan 0.0500 0.0001
80 0.0038 nan 0.0500 -0.0001
100 0.0027 nan 0.0500 -0.0001
120 0.0019 nan 0.0500 -0.0000
140 0.0013 nan 0.0500 -0.0000
160 0.0011 nan 0.0500 -0.0000
180 0.0008 nan 0.0500 -0.0000
200 0.0006 nan 0.0500 0.0000
- Fold23: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold23: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0401 nan 0.0500 0.0037
2 0.0377 nan 0.0500 0.0019
3 0.0341 nan 0.0500 0.0025
4 0.0320 nan 0.0500 0.0011
5 0.0298 nan 0.0500 0.0010
6 0.0275 nan 0.0500 0.0020
7 0.0256 nan 0.0500 0.0012
8 0.0244 nan 0.0500 0.0003
9 0.0220 nan 0.0500 0.0025
10 0.0214 nan 0.0500 0.0001
20 0.0111 nan 0.0500 0.0004
40 0.0037 nan 0.0500 0.0000
60 0.0012 nan 0.0500 0.0000
80 0.0005 nan 0.0500 0.0000
100 0.0003 nan 0.0500 0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0001 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold23: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold23: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0421 nan 0.0500 0.0003
2 0.0401 nan 0.0500 0.0003
3 0.0370 nan 0.0500 0.0011
4 0.0351 nan 0.0500 0.0009
5 0.0324 nan 0.0500 0.0023
6 0.0302 nan 0.0500 0.0015
7 0.0277 nan 0.0500 0.0015
8 0.0254 nan 0.0500 0.0018
9 0.0234 nan 0.0500 0.0012
10 0.0216 nan 0.0500 0.0010
20 0.0119 nan 0.0500 -0.0004
40 0.0041 nan 0.0500 0.0002
60 0.0020 nan 0.0500 -0.0000
80 0.0011 nan 0.0500 0.0000
100 0.0007 nan 0.0500 -0.0000
120 0.0005 nan 0.0500 0.0000
140 0.0003 nan 0.0500 -0.0000
160 0.0003 nan 0.0500 -0.0000
180 0.0002 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold23: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold23: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0417 nan 0.0500 0.0025
2 0.0399 nan 0.0500 0.0009
3 0.0381 nan 0.0500 0.0012
4 0.0365 nan 0.0500 0.0006
5 0.0347 nan 0.0500 0.0011
6 0.0328 nan 0.0500 0.0016
7 0.0311 nan 0.0500 0.0019
8 0.0291 nan 0.0500 0.0014
9 0.0273 nan 0.0500 0.0007
10 0.0261 nan 0.0500 0.0009
20 0.0164 nan 0.0500 0.0001
40 0.0077 nan 0.0500 0.0002
60 0.0046 nan 0.0500 0.0001
80 0.0029 nan 0.0500 -0.0000
100 0.0019 nan 0.0500 -0.0000
120 0.0012 nan 0.0500 -0.0000
140 0.0009 nan 0.0500 -0.0000
160 0.0006 nan 0.0500 -0.0000
180 0.0005 nan 0.0500 0.0000
200 0.0003 nan 0.0500 -0.0000
- Fold23: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold23: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0408 nan 0.0500 0.0039
2 0.0372 nan 0.0500 0.0035
3 0.0346 nan 0.0500 0.0010
4 0.0323 nan 0.0500 0.0011
5 0.0295 nan 0.0500 0.0021
6 0.0273 nan 0.0500 0.0010
7 0.0259 nan 0.0500 0.0004
8 0.0241 nan 0.0500 0.0011
9 0.0230 nan 0.0500 0.0006
10 0.0210 nan 0.0500 0.0015
20 0.0111 nan 0.0500 0.0002
40 0.0040 nan 0.0500 0.0001
60 0.0014 nan 0.0500 -0.0001
80 0.0005 nan 0.0500 -0.0000
100 0.0002 nan 0.0500 -0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0000 nan 0.0500 0.0000
160 0.0000 nan 0.0500 0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold23: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold23: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0413 nan 0.0500 0.0034
2 0.0388 nan 0.0500 0.0023
3 0.0362 nan 0.0500 0.0024
4 0.0351 nan 0.0500 0.0003
5 0.0320 nan 0.0500 0.0027
6 0.0309 nan 0.0500 0.0007
7 0.0286 nan 0.0500 0.0015
8 0.0267 nan 0.0500 0.0018
9 0.0249 nan 0.0500 0.0010
10 0.0223 nan 0.0500 0.0013
20 0.0118 nan 0.0500 0.0007
40 0.0048 nan 0.0500 0.0002
60 0.0021 nan 0.0500 0.0000
80 0.0011 nan 0.0500 0.0000
100 0.0007 nan 0.0500 -0.0000
120 0.0005 nan 0.0500 0.0000
140 0.0003 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold23: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold23: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0412 nan 0.0500 0.0029
2 0.0388 nan 0.0500 0.0011
3 0.0358 nan 0.0500 0.0024
4 0.0333 nan 0.0500 0.0019
5 0.0312 nan 0.0500 0.0018
6 0.0298 nan 0.0500 0.0011
7 0.0282 nan 0.0500 0.0015
8 0.0267 nan 0.0500 0.0008
9 0.0251 nan 0.0500 0.0015
10 0.0237 nan 0.0500 0.0013
20 0.0143 nan 0.0500 0.0001
40 0.0064 nan 0.0500 -0.0000
60 0.0040 nan 0.0500 0.0000
80 0.0027 nan 0.0500 0.0001
100 0.0021 nan 0.0500 0.0000
120 0.0016 nan 0.0500 -0.0000
140 0.0012 nan 0.0500 -0.0000
160 0.0009 nan 0.0500 0.0000
180 0.0007 nan 0.0500 -0.0000
200 0.0005 nan 0.0500 -0.0000
- Fold23: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold23: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0384 nan 0.1000 0.0031
2 0.0344 nan 0.1000 0.0018
3 0.0301 nan 0.1000 0.0038
4 0.0269 nan 0.1000 0.0010
5 0.0236 nan 0.1000 0.0032
6 0.0204 nan 0.1000 0.0017
7 0.0182 nan 0.1000 0.0024
8 0.0170 nan 0.1000 0.0010
9 0.0162 nan 0.1000 -0.0000
10 0.0143 nan 0.1000 0.0015
20 0.0058 nan 0.1000 0.0004
40 0.0014 nan 0.1000 -0.0000
60 0.0004 nan 0.1000 -0.0000
80 0.0002 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold23: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold23: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0382 nan 0.1000 0.0052
2 0.0343 nan 0.1000 0.0004
3 0.0320 nan 0.1000 0.0006
4 0.0272 nan 0.1000 0.0034
5 0.0256 nan 0.1000 0.0006
6 0.0225 nan 0.1000 0.0021
7 0.0191 nan 0.1000 0.0024
8 0.0186 nan 0.1000 -0.0001
9 0.0172 nan 0.1000 0.0011
10 0.0153 nan 0.1000 0.0021
20 0.0062 nan 0.1000 0.0003
40 0.0018 nan 0.1000 -0.0000
60 0.0008 nan 0.1000 -0.0001
80 0.0004 nan 0.1000 0.0000
100 0.0002 nan 0.1000 0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold23: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold23: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0385 nan 0.1000 0.0027
2 0.0350 nan 0.1000 0.0036
3 0.0317 nan 0.1000 0.0025
4 0.0286 nan 0.1000 0.0037
5 0.0265 nan 0.1000 0.0007
6 0.0248 nan 0.1000 0.0005
7 0.0224 nan 0.1000 0.0019
8 0.0201 nan 0.1000 0.0025
9 0.0188 nan 0.1000 0.0012
10 0.0177 nan 0.1000 0.0001
20 0.0113 nan 0.1000 0.0004
40 0.0037 nan 0.1000 -0.0002
60 0.0017 nan 0.1000 -0.0000
80 0.0012 nan 0.1000 -0.0000
100 0.0006 nan 0.1000 -0.0000
120 0.0004 nan 0.1000 -0.0000
140 0.0003 nan 0.1000 0.0000
160 0.0002 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold23: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold23: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0395 nan 0.1000 0.0041
2 0.0344 nan 0.1000 0.0033
3 0.0291 nan 0.1000 0.0059
4 0.0270 nan 0.1000 0.0013
5 0.0239 nan 0.1000 0.0026
6 0.0217 nan 0.1000 0.0009
7 0.0200 nan 0.1000 0.0015
8 0.0182 nan 0.1000 0.0014
9 0.0168 nan 0.1000 0.0003
10 0.0151 nan 0.1000 0.0007
20 0.0053 nan 0.1000 0.0005
40 0.0008 nan 0.1000 -0.0000
60 0.0002 nan 0.1000 -0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold23: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold23: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0406 nan 0.1000 -0.0017
2 0.0357 nan 0.1000 0.0052
3 0.0338 nan 0.1000 0.0004
4 0.0297 nan 0.1000 0.0018
5 0.0257 nan 0.1000 0.0035
6 0.0238 nan 0.1000 0.0008
7 0.0202 nan 0.1000 0.0034
8 0.0178 nan 0.1000 0.0017
9 0.0159 nan 0.1000 0.0005
10 0.0151 nan 0.1000 -0.0005
20 0.0060 nan 0.1000 -0.0005
40 0.0016 nan 0.1000 0.0001
60 0.0006 nan 0.1000 0.0000
80 0.0002 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold23: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold23: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0387 nan 0.1000 0.0058
2 0.0346 nan 0.1000 0.0048
3 0.0302 nan 0.1000 0.0032
4 0.0270 nan 0.1000 0.0013
5 0.0242 nan 0.1000 -0.0007
6 0.0214 nan 0.1000 0.0026
7 0.0197 nan 0.1000 0.0021
8 0.0185 nan 0.1000 0.0009
9 0.0166 nan 0.1000 0.0017
10 0.0151 nan 0.1000 0.0015
20 0.0078 nan 0.1000 -0.0001
40 0.0035 nan 0.1000 0.0000
60 0.0018 nan 0.1000 0.0000
80 0.0008 nan 0.1000 0.0000
100 0.0005 nan 0.1000 -0.0000
120 0.0003 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold23: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold23: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0357 nan 0.1000 0.0071
2 0.0320 nan 0.1000 0.0004
3 0.0280 nan 0.1000 0.0011
4 0.0248 nan 0.1000 -0.0004
5 0.0237 nan 0.1000 -0.0001
6 0.0195 nan 0.1000 0.0033
7 0.0172 nan 0.1000 0.0020
8 0.0147 nan 0.1000 0.0017
9 0.0128 nan 0.1000 0.0011
10 0.0114 nan 0.1000 0.0012
20 0.0028 nan 0.1000 0.0005
40 0.0004 nan 0.1000 -0.0000
60 0.0001 nan 0.1000 -0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 0.0000
120 0.0000 nan 0.1000 0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold23: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold23: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0399 nan 0.1000 0.0030
2 0.0339 nan 0.1000 0.0052
3 0.0301 nan 0.1000 0.0037
4 0.0265 nan 0.1000 -0.0003
5 0.0231 nan 0.1000 0.0029
6 0.0203 nan 0.1000 0.0015
7 0.0179 nan 0.1000 0.0007
8 0.0156 nan 0.1000 0.0022
9 0.0132 nan 0.1000 0.0019
10 0.0115 nan 0.1000 0.0013
20 0.0038 nan 0.1000 0.0001
40 0.0010 nan 0.1000 -0.0000
60 0.0003 nan 0.1000 -0.0000
80 0.0002 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 0.0000
- Fold23: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold23: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0386 nan 0.1000 0.0053
2 0.0343 nan 0.1000 0.0040
3 0.0321 nan 0.1000 0.0019
4 0.0278 nan 0.1000 0.0039
5 0.0268 nan 0.1000 -0.0007
6 0.0252 nan 0.1000 0.0008
7 0.0220 nan 0.1000 0.0026
8 0.0206 nan 0.1000 0.0003
9 0.0191 nan 0.1000 -0.0003
10 0.0172 nan 0.1000 0.0014
20 0.0071 nan 0.1000 0.0002
40 0.0032 nan 0.1000 -0.0001
60 0.0015 nan 0.1000 -0.0000
80 0.0007 nan 0.1000 -0.0000
100 0.0005 nan 0.1000 -0.0000
120 0.0003 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold23: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold24: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0427 nan 0.0100 0.0005
2 0.0423 nan 0.0100 0.0001
3 0.0417 nan 0.0100 0.0006
4 0.0412 nan 0.0100 0.0005
5 0.0406 nan 0.0100 0.0003
6 0.0401 nan 0.0100 0.0005
7 0.0395 nan 0.0100 0.0005
8 0.0390 nan 0.0100 0.0004
9 0.0386 nan 0.0100 0.0003
10 0.0381 nan 0.0100 0.0004
20 0.0339 nan 0.0100 0.0004
40 0.0267 nan 0.0100 0.0003
60 0.0213 nan 0.0100 -0.0001
80 0.0177 nan 0.0100 0.0001
100 0.0146 nan 0.0100 0.0000
120 0.0121 nan 0.0100 0.0001
140 0.0104 nan 0.0100 0.0001
160 0.0088 nan 0.0100 0.0000
180 0.0074 nan 0.0100 -0.0000
200 0.0063 nan 0.0100 0.0000
- Fold24: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold24: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0426 nan 0.0100 0.0006
2 0.0422 nan 0.0100 0.0002
3 0.0419 nan 0.0100 0.0000
4 0.0413 nan 0.0100 0.0006
5 0.0409 nan 0.0100 0.0000
6 0.0405 nan 0.0100 0.0005
7 0.0401 nan 0.0100 0.0003
8 0.0396 nan 0.0100 0.0004
9 0.0391 nan 0.0100 0.0005
10 0.0388 nan 0.0100 0.0002
20 0.0344 nan 0.0100 -0.0000
40 0.0281 nan 0.0100 -0.0000
60 0.0226 nan 0.0100 0.0002
80 0.0183 nan 0.0100 0.0002
100 0.0152 nan 0.0100 0.0001
120 0.0125 nan 0.0100 -0.0000
140 0.0106 nan 0.0100 0.0000
160 0.0089 nan 0.0100 0.0000
180 0.0076 nan 0.0100 -0.0000
200 0.0066 nan 0.0100 0.0000
- Fold24: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold24: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0427 nan 0.0100 0.0005
2 0.0422 nan 0.0100 0.0003
3 0.0418 nan 0.0100 0.0004
4 0.0417 nan 0.0100 -0.0003
5 0.0411 nan 0.0100 0.0004
6 0.0405 nan 0.0100 0.0005
7 0.0399 nan 0.0100 0.0005
8 0.0396 nan 0.0100 0.0001
9 0.0392 nan 0.0100 0.0002
10 0.0389 nan 0.0100 -0.0000
20 0.0347 nan 0.0100 0.0001
40 0.0284 nan 0.0100 0.0002
60 0.0238 nan 0.0100 0.0001
80 0.0192 nan 0.0100 0.0001
100 0.0157 nan 0.0100 0.0001
120 0.0136 nan 0.0100 0.0001
140 0.0117 nan 0.0100 -0.0000
160 0.0103 nan 0.0100 0.0001
180 0.0089 nan 0.0100 0.0000
200 0.0079 nan 0.0100 0.0000
- Fold24: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold24: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0426 nan 0.0100 0.0007
2 0.0419 nan 0.0100 0.0006
3 0.0412 nan 0.0100 0.0005
4 0.0406 nan 0.0100 0.0005
5 0.0400 nan 0.0100 0.0004
6 0.0397 nan 0.0100 0.0002
7 0.0391 nan 0.0100 0.0003
8 0.0390 nan 0.0100 -0.0002
9 0.0384 nan 0.0100 0.0004
10 0.0378 nan 0.0100 0.0006
20 0.0329 nan 0.0100 0.0003
40 0.0251 nan 0.0100 0.0002
60 0.0195 nan 0.0100 0.0003
80 0.0155 nan 0.0100 0.0001
100 0.0126 nan 0.0100 0.0000
120 0.0102 nan 0.0100 0.0001
140 0.0084 nan 0.0100 0.0000
160 0.0069 nan 0.0100 -0.0000
180 0.0056 nan 0.0100 0.0000
200 0.0045 nan 0.0100 0.0001
- Fold24: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold24: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0426 nan 0.0100 0.0006
2 0.0420 nan 0.0100 0.0005
3 0.0413 nan 0.0100 0.0005
4 0.0406 nan 0.0100 0.0005
5 0.0401 nan 0.0100 0.0005
6 0.0397 nan 0.0100 0.0001
7 0.0393 nan 0.0100 0.0003
8 0.0389 nan 0.0100 0.0003
9 0.0386 nan 0.0100 0.0003
10 0.0378 nan 0.0100 0.0005
20 0.0322 nan 0.0100 0.0004
40 0.0246 nan 0.0100 0.0002
60 0.0191 nan 0.0100 0.0001
80 0.0150 nan 0.0100 0.0001
100 0.0118 nan 0.0100 0.0001
120 0.0094 nan 0.0100 0.0001
140 0.0078 nan 0.0100 0.0001
160 0.0066 nan 0.0100 0.0000
180 0.0054 nan 0.0100 -0.0000
200 0.0046 nan 0.0100 0.0000
- Fold24: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold24: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0425 nan 0.0100 0.0005
2 0.0420 nan 0.0100 0.0005
3 0.0414 nan 0.0100 0.0006
4 0.0409 nan 0.0100 0.0006
5 0.0404 nan 0.0100 0.0005
6 0.0398 nan 0.0100 0.0003
7 0.0392 nan 0.0100 0.0004
8 0.0388 nan 0.0100 0.0002
9 0.0383 nan 0.0100 0.0003
10 0.0377 nan 0.0100 0.0004
20 0.0336 nan 0.0100 0.0002
40 0.0269 nan 0.0100 0.0003
60 0.0219 nan 0.0100 0.0002
80 0.0186 nan 0.0100 0.0002
100 0.0159 nan 0.0100 0.0001
120 0.0136 nan 0.0100 0.0001
140 0.0120 nan 0.0100 -0.0000
160 0.0106 nan 0.0100 -0.0000
180 0.0096 nan 0.0100 0.0000
200 0.0086 nan 0.0100 -0.0000
- Fold24: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold24: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0427 nan 0.0100 0.0000
2 0.0420 nan 0.0100 0.0006
3 0.0417 nan 0.0100 -0.0000
4 0.0411 nan 0.0100 0.0003
5 0.0404 nan 0.0100 0.0005
6 0.0398 nan 0.0100 0.0004
7 0.0391 nan 0.0100 0.0005
8 0.0387 nan 0.0100 0.0005
9 0.0381 nan 0.0100 0.0004
10 0.0374 nan 0.0100 0.0006
20 0.0330 nan 0.0100 0.0003
40 0.0246 nan 0.0100 0.0003
60 0.0187 nan 0.0100 0.0000
80 0.0140 nan 0.0100 0.0001
100 0.0109 nan 0.0100 0.0001
120 0.0087 nan 0.0100 0.0001
140 0.0068 nan 0.0100 0.0000
160 0.0054 nan 0.0100 0.0001
180 0.0043 nan 0.0100 0.0000
200 0.0034 nan 0.0100 0.0000
- Fold24: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold24: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0425 nan 0.0100 0.0006
2 0.0418 nan 0.0100 0.0006
3 0.0412 nan 0.0100 0.0004
4 0.0409 nan 0.0100 -0.0000
5 0.0403 nan 0.0100 0.0004
6 0.0397 nan 0.0100 0.0005
7 0.0391 nan 0.0100 0.0007
8 0.0385 nan 0.0100 0.0005
9 0.0377 nan 0.0100 0.0004
10 0.0372 nan 0.0100 0.0004
20 0.0320 nan 0.0100 0.0002
40 0.0243 nan 0.0100 0.0002
60 0.0190 nan 0.0100 0.0002
80 0.0150 nan 0.0100 0.0000
100 0.0121 nan 0.0100 0.0001
120 0.0095 nan 0.0100 0.0001
140 0.0077 nan 0.0100 0.0001
160 0.0062 nan 0.0100 0.0000
180 0.0050 nan 0.0100 0.0000
200 0.0041 nan 0.0100 -0.0000
- Fold24: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold24: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0427 nan 0.0100 0.0004
2 0.0421 nan 0.0100 0.0003
3 0.0417 nan 0.0100 0.0003
4 0.0412 nan 0.0100 0.0003
5 0.0406 nan 0.0100 0.0004
6 0.0402 nan 0.0100 0.0004
7 0.0399 nan 0.0100 0.0001
8 0.0394 nan 0.0100 0.0005
9 0.0388 nan 0.0100 0.0004
10 0.0384 nan 0.0100 0.0004
20 0.0343 nan 0.0100 0.0005
40 0.0275 nan 0.0100 0.0001
60 0.0226 nan 0.0100 0.0002
80 0.0187 nan 0.0100 0.0000
100 0.0157 nan 0.0100 0.0000
120 0.0135 nan 0.0100 0.0000
140 0.0116 nan 0.0100 0.0000
160 0.0103 nan 0.0100 -0.0000
180 0.0094 nan 0.0100 0.0001
200 0.0085 nan 0.0100 -0.0001
- Fold24: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold24: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0413 nan 0.0500 0.0005
2 0.0395 nan 0.0500 0.0021
3 0.0362 nan 0.0500 0.0027
4 0.0336 nan 0.0500 0.0024
5 0.0319 nan 0.0500 0.0005
6 0.0299 nan 0.0500 0.0011
7 0.0282 nan 0.0500 0.0013
8 0.0261 nan 0.0500 0.0014
9 0.0246 nan 0.0500 0.0012
10 0.0234 nan 0.0500 0.0001
20 0.0144 nan 0.0500 0.0002
40 0.0065 nan 0.0500 0.0002
60 0.0030 nan 0.0500 -0.0000
80 0.0017 nan 0.0500 -0.0000
100 0.0010 nan 0.0500 -0.0000
120 0.0006 nan 0.0500 -0.0000
140 0.0003 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold24: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold24: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0409 nan 0.0500 0.0022
2 0.0378 nan 0.0500 0.0020
3 0.0366 nan 0.0500 -0.0009
4 0.0341 nan 0.0500 0.0016
5 0.0329 nan 0.0500 0.0011
6 0.0310 nan 0.0500 0.0010
7 0.0285 nan 0.0500 0.0019
8 0.0267 nan 0.0500 0.0013
9 0.0263 nan 0.0500 -0.0003
10 0.0247 nan 0.0500 0.0016
20 0.0149 nan 0.0500 0.0003
40 0.0065 nan 0.0500 -0.0000
60 0.0033 nan 0.0500 -0.0000
80 0.0023 nan 0.0500 -0.0001
100 0.0013 nan 0.0500 -0.0000
120 0.0008 nan 0.0500 -0.0000
140 0.0005 nan 0.0500 -0.0000
160 0.0004 nan 0.0500 0.0000
180 0.0003 nan 0.0500 0.0000
200 0.0002 nan 0.0500 -0.0000
- Fold24: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold24: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0412 nan 0.0500 0.0017
2 0.0381 nan 0.0500 0.0029
3 0.0358 nan 0.0500 0.0014
4 0.0339 nan 0.0500 0.0011
5 0.0320 nan 0.0500 0.0021
6 0.0297 nan 0.0500 0.0017
7 0.0279 nan 0.0500 0.0014
8 0.0263 nan 0.0500 0.0015
9 0.0249 nan 0.0500 0.0014
10 0.0233 nan 0.0500 0.0010
20 0.0160 nan 0.0500 0.0004
40 0.0082 nan 0.0500 -0.0000
60 0.0050 nan 0.0500 0.0000
80 0.0034 nan 0.0500 0.0000
100 0.0026 nan 0.0500 0.0000
120 0.0017 nan 0.0500 -0.0000
140 0.0012 nan 0.0500 -0.0000
160 0.0008 nan 0.0500 0.0000
180 0.0006 nan 0.0500 -0.0000
200 0.0004 nan 0.0500 -0.0000
- Fold24: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold24: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0397 nan 0.0500 0.0020
2 0.0362 nan 0.0500 0.0030
3 0.0327 nan 0.0500 0.0033
4 0.0312 nan 0.0500 0.0013
5 0.0300 nan 0.0500 0.0002
6 0.0276 nan 0.0500 0.0007
7 0.0254 nan 0.0500 0.0026
8 0.0235 nan 0.0500 0.0012
9 0.0225 nan 0.0500 0.0009
10 0.0211 nan 0.0500 0.0014
20 0.0107 nan 0.0500 0.0003
40 0.0035 nan 0.0500 0.0001
60 0.0013 nan 0.0500 -0.0000
80 0.0006 nan 0.0500 -0.0000
100 0.0003 nan 0.0500 0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0001 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 0.0000
180 0.0000 nan 0.0500 0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold24: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold24: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0406 nan 0.0500 0.0030
2 0.0380 nan 0.0500 0.0015
3 0.0355 nan 0.0500 0.0026
4 0.0337 nan 0.0500 0.0013
5 0.0311 nan 0.0500 0.0021
6 0.0291 nan 0.0500 0.0013
7 0.0275 nan 0.0500 0.0016
8 0.0261 nan 0.0500 0.0007
9 0.0246 nan 0.0500 0.0013
10 0.0228 nan 0.0500 0.0014
20 0.0121 nan 0.0500 0.0007
40 0.0048 nan 0.0500 0.0001
60 0.0022 nan 0.0500 -0.0001
80 0.0010 nan 0.0500 0.0000
100 0.0006 nan 0.0500 -0.0000
120 0.0004 nan 0.0500 0.0000
140 0.0003 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold24: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold24: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0414 nan 0.0500 0.0010
2 0.0394 nan 0.0500 0.0005
3 0.0369 nan 0.0500 0.0023
4 0.0345 nan 0.0500 0.0018
5 0.0331 nan 0.0500 0.0011
6 0.0320 nan 0.0500 0.0001
7 0.0294 nan 0.0500 0.0018
8 0.0289 nan 0.0500 -0.0007
9 0.0282 nan 0.0500 -0.0001
10 0.0267 nan 0.0500 0.0010
20 0.0162 nan 0.0500 -0.0000
40 0.0085 nan 0.0500 -0.0000
60 0.0052 nan 0.0500 0.0001
80 0.0034 nan 0.0500 -0.0001
100 0.0022 nan 0.0500 0.0000
120 0.0017 nan 0.0500 -0.0000
140 0.0012 nan 0.0500 0.0000
160 0.0009 nan 0.0500 -0.0000
180 0.0007 nan 0.0500 -0.0000
200 0.0005 nan 0.0500 -0.0000
- Fold24: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold24: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0393 nan 0.0500 0.0038
2 0.0357 nan 0.0500 0.0031
3 0.0328 nan 0.0500 0.0007
4 0.0299 nan 0.0500 0.0017
5 0.0287 nan 0.0500 0.0008
6 0.0266 nan 0.0500 0.0018
7 0.0248 nan 0.0500 0.0010
8 0.0232 nan 0.0500 0.0014
9 0.0219 nan 0.0500 0.0008
10 0.0202 nan 0.0500 0.0015
20 0.0100 nan 0.0500 0.0003
40 0.0032 nan 0.0500 0.0001
60 0.0011 nan 0.0500 0.0000
80 0.0005 nan 0.0500 0.0000
100 0.0002 nan 0.0500 -0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0000 nan 0.0500 0.0000
160 0.0000 nan 0.0500 0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold24: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold24: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0408 nan 0.0500 0.0025
2 0.0384 nan 0.0500 0.0027
3 0.0370 nan 0.0500 0.0010
4 0.0340 nan 0.0500 0.0021
5 0.0325 nan 0.0500 0.0009
6 0.0303 nan 0.0500 0.0021
7 0.0286 nan 0.0500 0.0012
8 0.0267 nan 0.0500 0.0010
9 0.0245 nan 0.0500 0.0014
10 0.0232 nan 0.0500 0.0010
20 0.0119 nan 0.0500 0.0008
40 0.0041 nan 0.0500 0.0001
60 0.0018 nan 0.0500 0.0000
80 0.0011 nan 0.0500 -0.0000
100 0.0006 nan 0.0500 0.0000
120 0.0004 nan 0.0500 -0.0000
140 0.0003 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold24: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold24: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0407 nan 0.0500 0.0014
2 0.0378 nan 0.0500 0.0028
3 0.0359 nan 0.0500 -0.0000
4 0.0341 nan 0.0500 0.0009
5 0.0317 nan 0.0500 0.0017
6 0.0297 nan 0.0500 0.0018
7 0.0282 nan 0.0500 0.0014
8 0.0266 nan 0.0500 0.0003
9 0.0248 nan 0.0500 0.0014
10 0.0233 nan 0.0500 0.0007
20 0.0144 nan 0.0500 0.0003
40 0.0082 nan 0.0500 -0.0002
60 0.0053 nan 0.0500 -0.0000
80 0.0034 nan 0.0500 -0.0000
100 0.0023 nan 0.0500 0.0000
120 0.0017 nan 0.0500 0.0000
140 0.0014 nan 0.0500 -0.0000
160 0.0010 nan 0.0500 0.0000
180 0.0008 nan 0.0500 -0.0000
200 0.0006 nan 0.0500 -0.0000
- Fold24: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold24: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0383 nan 0.1000 0.0056
2 0.0342 nan 0.1000 0.0034
3 0.0302 nan 0.1000 0.0042
4 0.0268 nan 0.1000 0.0031
5 0.0237 nan 0.1000 0.0020
6 0.0206 nan 0.1000 0.0027
7 0.0182 nan 0.1000 0.0013
8 0.0165 nan 0.1000 0.0012
9 0.0153 nan 0.1000 0.0010
10 0.0142 nan 0.1000 0.0010
20 0.0060 nan 0.1000 0.0002
40 0.0015 nan 0.1000 0.0001
60 0.0005 nan 0.1000 0.0000
80 0.0002 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold24: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold24: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0401 nan 0.1000 -0.0005
2 0.0339 nan 0.1000 0.0044
3 0.0302 nan 0.1000 0.0031
4 0.0274 nan 0.1000 0.0030
5 0.0255 nan 0.1000 0.0008
6 0.0246 nan 0.1000 -0.0011
7 0.0210 nan 0.1000 0.0021
8 0.0195 nan 0.1000 0.0001
9 0.0181 nan 0.1000 0.0004
10 0.0159 nan 0.1000 0.0009
20 0.0082 nan 0.1000 0.0002
40 0.0027 nan 0.1000 -0.0001
60 0.0013 nan 0.1000 -0.0001
80 0.0006 nan 0.1000 -0.0000
100 0.0003 nan 0.1000 -0.0000
120 0.0002 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold24: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold24: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0391 nan 0.1000 0.0005
2 0.0341 nan 0.1000 0.0049
3 0.0292 nan 0.1000 0.0037
4 0.0263 nan 0.1000 0.0032
5 0.0234 nan 0.1000 0.0031
6 0.0207 nan 0.1000 0.0015
7 0.0197 nan 0.1000 0.0004
8 0.0175 nan 0.1000 0.0017
9 0.0164 nan 0.1000 0.0012
10 0.0157 nan 0.1000 0.0004
20 0.0080 nan 0.1000 -0.0000
40 0.0041 nan 0.1000 -0.0001
60 0.0022 nan 0.1000 0.0000
80 0.0014 nan 0.1000 -0.0001
100 0.0008 nan 0.1000 0.0000
120 0.0004 nan 0.1000 0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 0.0000
200 0.0001 nan 0.1000 0.0000
- Fold24: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold24: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0391 nan 0.1000 0.0021
2 0.0363 nan 0.1000 -0.0000
3 0.0313 nan 0.1000 0.0051
4 0.0261 nan 0.1000 0.0046
5 0.0236 nan 0.1000 0.0019
6 0.0207 nan 0.1000 0.0013
7 0.0175 nan 0.1000 0.0020
8 0.0155 nan 0.1000 0.0007
9 0.0134 nan 0.1000 0.0017
10 0.0125 nan 0.1000 0.0004
20 0.0036 nan 0.1000 0.0003
40 0.0007 nan 0.1000 0.0000
60 0.0002 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold24: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold24: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0383 nan 0.1000 0.0017
2 0.0324 nan 0.1000 0.0051
3 0.0286 nan 0.1000 0.0031
4 0.0240 nan 0.1000 0.0038
5 0.0199 nan 0.1000 0.0019
6 0.0172 nan 0.1000 0.0015
7 0.0152 nan 0.1000 0.0018
8 0.0138 nan 0.1000 0.0010
9 0.0122 nan 0.1000 0.0015
10 0.0111 nan 0.1000 0.0005
20 0.0041 nan 0.1000 0.0003
40 0.0010 nan 0.1000 -0.0001
60 0.0003 nan 0.1000 0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold24: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold24: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0377 nan 0.1000 0.0050
2 0.0355 nan 0.1000 0.0000
3 0.0306 nan 0.1000 0.0040
4 0.0276 nan 0.1000 0.0029
5 0.0255 nan 0.1000 0.0007
6 0.0218 nan 0.1000 0.0015
7 0.0194 nan 0.1000 0.0016
8 0.0172 nan 0.1000 0.0005
9 0.0164 nan 0.1000 0.0009
10 0.0161 nan 0.1000 -0.0002
20 0.0087 nan 0.1000 0.0003
40 0.0039 nan 0.1000 0.0001
60 0.0019 nan 0.1000 0.0000
80 0.0013 nan 0.1000 -0.0000
100 0.0008 nan 0.1000 -0.0001
120 0.0005 nan 0.1000 -0.0000
140 0.0003 nan 0.1000 -0.0000
160 0.0002 nan 0.1000 -0.0000
180 0.0002 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold24: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold24: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0370 nan 0.1000 0.0030
2 0.0335 nan 0.1000 -0.0008
3 0.0278 nan 0.1000 0.0039
4 0.0230 nan 0.1000 0.0034
5 0.0212 nan 0.1000 0.0016
6 0.0184 nan 0.1000 0.0010
7 0.0165 nan 0.1000 0.0009
8 0.0139 nan 0.1000 0.0027
9 0.0119 nan 0.1000 0.0010
10 0.0109 nan 0.1000 -0.0001
20 0.0033 nan 0.1000 0.0004
40 0.0004 nan 0.1000 -0.0000
60 0.0001 nan 0.1000 -0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold24: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold24: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0358 nan 0.1000 0.0075
2 0.0322 nan 0.1000 0.0026
3 0.0282 nan 0.1000 0.0037
4 0.0247 nan 0.1000 0.0023
5 0.0218 nan 0.1000 0.0024
6 0.0186 nan 0.1000 -0.0000
7 0.0162 nan 0.1000 0.0015
8 0.0149 nan 0.1000 0.0010
9 0.0138 nan 0.1000 0.0008
10 0.0119 nan 0.1000 0.0020
20 0.0038 nan 0.1000 0.0002
40 0.0014 nan 0.1000 -0.0000
60 0.0006 nan 0.1000 -0.0000
80 0.0002 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0001 nan 0.1000 0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold24: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold24: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0374 nan 0.1000 0.0039
2 0.0344 nan 0.1000 -0.0008
3 0.0290 nan 0.1000 0.0036
4 0.0274 nan 0.1000 0.0002
5 0.0236 nan 0.1000 0.0008
6 0.0213 nan 0.1000 0.0011
7 0.0202 nan 0.1000 0.0011
8 0.0195 nan 0.1000 0.0005
9 0.0169 nan 0.1000 0.0014
10 0.0148 nan 0.1000 0.0004
20 0.0074 nan 0.1000 -0.0003
40 0.0037 nan 0.1000 -0.0001
60 0.0016 nan 0.1000 -0.0000
80 0.0008 nan 0.1000 -0.0000
100 0.0004 nan 0.1000 -0.0000
120 0.0002 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 0.0000
- Fold24: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold25: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0393 nan 0.0100 -0.0001
2 0.0391 nan 0.0100 -0.0001
3 0.0386 nan 0.0100 0.0005
4 0.0382 nan 0.0100 0.0003
5 0.0377 nan 0.0100 0.0002
6 0.0374 nan 0.0100 0.0003
7 0.0371 nan 0.0100 0.0001
8 0.0366 nan 0.0100 0.0005
9 0.0363 nan 0.0100 0.0001
10 0.0359 nan 0.0100 0.0002
20 0.0319 nan 0.0100 0.0004
40 0.0252 nan 0.0100 0.0001
60 0.0207 nan 0.0100 0.0002
80 0.0171 nan 0.0100 0.0001
100 0.0144 nan 0.0100 0.0001
120 0.0120 nan 0.0100 0.0001
140 0.0101 nan 0.0100 0.0001
160 0.0087 nan 0.0100 0.0000
180 0.0075 nan 0.0100 0.0000
200 0.0064 nan 0.0100 0.0000
- Fold25: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold25: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0389 nan 0.0100 0.0005
2 0.0386 nan 0.0100 0.0001
3 0.0382 nan 0.0100 0.0002
4 0.0377 nan 0.0100 0.0005
5 0.0373 nan 0.0100 0.0002
6 0.0371 nan 0.0100 0.0001
7 0.0368 nan 0.0100 -0.0000
8 0.0363 nan 0.0100 0.0006
9 0.0358 nan 0.0100 0.0004
10 0.0353 nan 0.0100 0.0005
20 0.0314 nan 0.0100 0.0001
40 0.0259 nan 0.0100 0.0000
60 0.0209 nan 0.0100 0.0002
80 0.0176 nan 0.0100 0.0001
100 0.0148 nan 0.0100 0.0001
120 0.0125 nan 0.0100 0.0001
140 0.0109 nan 0.0100 0.0001
160 0.0092 nan 0.0100 0.0000
180 0.0079 nan 0.0100 0.0000
200 0.0066 nan 0.0100 0.0001
- Fold25: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold25: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0390 nan 0.0100 0.0005
2 0.0385 nan 0.0100 0.0004
3 0.0380 nan 0.0100 0.0003
4 0.0377 nan 0.0100 0.0002
5 0.0372 nan 0.0100 0.0001
6 0.0370 nan 0.0100 0.0001
7 0.0366 nan 0.0100 0.0004
8 0.0362 nan 0.0100 0.0005
9 0.0357 nan 0.0100 0.0004
10 0.0351 nan 0.0100 0.0005
20 0.0311 nan 0.0100 0.0001
40 0.0255 nan 0.0100 0.0002
60 0.0209 nan 0.0100 0.0001
80 0.0176 nan 0.0100 0.0001
100 0.0151 nan 0.0100 0.0001
120 0.0131 nan 0.0100 0.0001
140 0.0117 nan 0.0100 0.0000
160 0.0103 nan 0.0100 0.0000
180 0.0092 nan 0.0100 0.0000
200 0.0082 nan 0.0100 0.0000
- Fold25: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold25: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0389 nan 0.0100 0.0005
2 0.0384 nan 0.0100 0.0005
3 0.0379 nan 0.0100 0.0005
4 0.0374 nan 0.0100 0.0002
5 0.0368 nan 0.0100 0.0006
6 0.0365 nan 0.0100 0.0000
7 0.0358 nan 0.0100 0.0006
8 0.0353 nan 0.0100 0.0004
9 0.0350 nan 0.0100 -0.0001
10 0.0345 nan 0.0100 0.0003
20 0.0302 nan 0.0100 0.0004
40 0.0231 nan 0.0100 0.0003
60 0.0184 nan 0.0100 0.0002
80 0.0143 nan 0.0100 0.0001
100 0.0113 nan 0.0100 0.0001
120 0.0090 nan 0.0100 0.0000
140 0.0072 nan 0.0100 0.0000
160 0.0058 nan 0.0100 -0.0000
180 0.0048 nan 0.0100 0.0000
200 0.0041 nan 0.0100 -0.0000
- Fold25: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold25: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0389 nan 0.0100 0.0006
2 0.0385 nan 0.0100 0.0004
3 0.0380 nan 0.0100 0.0004
4 0.0375 nan 0.0100 0.0003
5 0.0370 nan 0.0100 0.0000
6 0.0365 nan 0.0100 0.0004
7 0.0361 nan 0.0100 0.0004
8 0.0356 nan 0.0100 0.0002
9 0.0351 nan 0.0100 0.0003
10 0.0346 nan 0.0100 0.0005
20 0.0303 nan 0.0100 0.0005
40 0.0234 nan 0.0100 0.0002
60 0.0184 nan 0.0100 0.0002
80 0.0144 nan 0.0100 0.0001
100 0.0117 nan 0.0100 0.0001
120 0.0095 nan 0.0100 0.0001
140 0.0077 nan 0.0100 -0.0000
160 0.0064 nan 0.0100 0.0000
180 0.0055 nan 0.0100 0.0000
200 0.0046 nan 0.0100 -0.0000
- Fold25: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold25: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0390 nan 0.0100 0.0005
2 0.0385 nan 0.0100 0.0004
3 0.0379 nan 0.0100 0.0005
4 0.0374 nan 0.0100 0.0004
5 0.0369 nan 0.0100 0.0005
6 0.0365 nan 0.0100 0.0003
7 0.0360 nan 0.0100 0.0005
8 0.0357 nan 0.0100 0.0003
9 0.0354 nan 0.0100 0.0001
10 0.0350 nan 0.0100 0.0003
20 0.0309 nan 0.0100 0.0002
40 0.0254 nan 0.0100 0.0003
60 0.0208 nan 0.0100 0.0002
80 0.0174 nan 0.0100 0.0001
100 0.0150 nan 0.0100 0.0000
120 0.0129 nan 0.0100 0.0000
140 0.0113 nan 0.0100 0.0000
160 0.0099 nan 0.0100 0.0000
180 0.0089 nan 0.0100 0.0000
200 0.0081 nan 0.0100 -0.0000
- Fold25: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold25: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0388 nan 0.0100 0.0007
2 0.0383 nan 0.0100 0.0003
3 0.0380 nan 0.0100 0.0002
4 0.0374 nan 0.0100 0.0005
5 0.0368 nan 0.0100 0.0005
6 0.0364 nan 0.0100 0.0003
7 0.0356 nan 0.0100 0.0006
8 0.0353 nan 0.0100 0.0002
9 0.0351 nan 0.0100 -0.0000
10 0.0347 nan 0.0100 0.0004
20 0.0299 nan 0.0100 0.0003
40 0.0235 nan 0.0100 -0.0000
60 0.0181 nan 0.0100 0.0003
80 0.0136 nan 0.0100 0.0001
100 0.0109 nan 0.0100 0.0001
120 0.0087 nan 0.0100 0.0002
140 0.0069 nan 0.0100 0.0001
160 0.0055 nan 0.0100 0.0001
180 0.0043 nan 0.0100 0.0000
200 0.0035 nan 0.0100 0.0000
- Fold25: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold25: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0391 nan 0.0100 0.0005
2 0.0386 nan 0.0100 0.0005
3 0.0381 nan 0.0100 0.0005
4 0.0375 nan 0.0100 0.0004
5 0.0369 nan 0.0100 0.0005
6 0.0364 nan 0.0100 0.0002
7 0.0360 nan 0.0100 0.0002
8 0.0355 nan 0.0100 0.0004
9 0.0349 nan 0.0100 0.0005
10 0.0342 nan 0.0100 0.0004
20 0.0296 nan 0.0100 0.0004
40 0.0227 nan 0.0100 0.0001
60 0.0180 nan 0.0100 0.0002
80 0.0141 nan 0.0100 0.0001
100 0.0110 nan 0.0100 -0.0000
120 0.0088 nan 0.0100 0.0001
140 0.0072 nan 0.0100 0.0000
160 0.0059 nan 0.0100 0.0001
180 0.0049 nan 0.0100 0.0000
200 0.0042 nan 0.0100 0.0000
- Fold25: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold25: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0392 nan 0.0100 0.0004
2 0.0389 nan 0.0100 0.0001
3 0.0385 nan 0.0100 0.0001
4 0.0382 nan 0.0100 0.0002
5 0.0377 nan 0.0100 0.0004
6 0.0373 nan 0.0100 0.0004
7 0.0368 nan 0.0100 0.0004
8 0.0363 nan 0.0100 0.0005
9 0.0361 nan 0.0100 -0.0000
10 0.0356 nan 0.0100 0.0004
20 0.0318 nan 0.0100 0.0004
40 0.0256 nan 0.0100 0.0002
60 0.0214 nan 0.0100 0.0002
80 0.0178 nan 0.0100 0.0002
100 0.0152 nan 0.0100 0.0001
120 0.0131 nan 0.0100 0.0001
140 0.0116 nan 0.0100 0.0000
160 0.0104 nan 0.0100 0.0000
180 0.0094 nan 0.0100 0.0001
200 0.0084 nan 0.0100 0.0000
- Fold25: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold25: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0373 nan 0.0500 0.0021
2 0.0354 nan 0.0500 0.0013
3 0.0329 nan 0.0500 0.0025
4 0.0311 nan 0.0500 0.0020
5 0.0298 nan 0.0500 0.0001
6 0.0290 nan 0.0500 -0.0002
7 0.0279 nan 0.0500 0.0001
8 0.0262 nan 0.0500 0.0017
9 0.0251 nan 0.0500 0.0011
10 0.0236 nan 0.0500 0.0015
20 0.0146 nan 0.0500 0.0007
40 0.0064 nan 0.0500 0.0001
60 0.0029 nan 0.0500 0.0001
80 0.0015 nan 0.0500 -0.0000
100 0.0009 nan 0.0500 -0.0000
120 0.0006 nan 0.0500 -0.0000
140 0.0004 nan 0.0500 0.0000
160 0.0002 nan 0.0500 0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 0.0000
- Fold25: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold25: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0377 nan 0.0500 0.0004
2 0.0358 nan 0.0500 0.0009
3 0.0343 nan 0.0500 0.0014
4 0.0321 nan 0.0500 0.0023
5 0.0300 nan 0.0500 0.0017
6 0.0286 nan 0.0500 0.0013
7 0.0270 nan 0.0500 0.0015
8 0.0254 nan 0.0500 0.0013
9 0.0239 nan 0.0500 0.0014
10 0.0225 nan 0.0500 0.0006
20 0.0139 nan 0.0500 0.0008
40 0.0063 nan 0.0500 0.0001
60 0.0031 nan 0.0500 0.0000
80 0.0017 nan 0.0500 -0.0000
100 0.0010 nan 0.0500 -0.0000
120 0.0006 nan 0.0500 -0.0000
140 0.0004 nan 0.0500 -0.0000
160 0.0003 nan 0.0500 -0.0000
180 0.0002 nan 0.0500 0.0000
200 0.0001 nan 0.0500 0.0000
- Fold25: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold25: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0371 nan 0.0500 0.0021
2 0.0345 nan 0.0500 0.0023
3 0.0320 nan 0.0500 0.0022
4 0.0296 nan 0.0500 0.0019
5 0.0281 nan 0.0500 0.0014
6 0.0264 nan 0.0500 0.0015
7 0.0253 nan 0.0500 0.0009
8 0.0235 nan 0.0500 0.0013
9 0.0221 nan 0.0500 0.0007
10 0.0210 nan 0.0500 0.0009
20 0.0143 nan 0.0500 0.0006
40 0.0086 nan 0.0500 -0.0002
60 0.0056 nan 0.0500 0.0001
80 0.0038 nan 0.0500 0.0000
100 0.0026 nan 0.0500 -0.0001
120 0.0018 nan 0.0500 0.0000
140 0.0014 nan 0.0500 -0.0000
160 0.0013 nan 0.0500 -0.0000
180 0.0010 nan 0.0500 -0.0000
200 0.0008 nan 0.0500 0.0000
- Fold25: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold25: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0368 nan 0.0500 0.0022
2 0.0345 nan 0.0500 0.0020
3 0.0319 nan 0.0500 0.0014
4 0.0295 nan 0.0500 0.0023
5 0.0285 nan 0.0500 -0.0001
6 0.0275 nan 0.0500 -0.0001
7 0.0251 nan 0.0500 0.0018
8 0.0238 nan 0.0500 0.0008
9 0.0228 nan 0.0500 0.0008
10 0.0219 nan 0.0500 -0.0002
20 0.0127 nan 0.0500 0.0002
40 0.0047 nan 0.0500 0.0001
60 0.0018 nan 0.0500 0.0000
80 0.0007 nan 0.0500 -0.0000
100 0.0004 nan 0.0500 0.0000
120 0.0002 nan 0.0500 0.0000
140 0.0001 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 0.0000
- Fold25: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold25: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0370 nan 0.0500 0.0024
2 0.0344 nan 0.0500 0.0019
3 0.0326 nan 0.0500 0.0020
4 0.0301 nan 0.0500 0.0020
5 0.0288 nan 0.0500 0.0007
6 0.0268 nan 0.0500 0.0019
7 0.0250 nan 0.0500 0.0020
8 0.0228 nan 0.0500 0.0009
9 0.0216 nan 0.0500 0.0008
10 0.0208 nan 0.0500 0.0007
20 0.0127 nan 0.0500 -0.0003
40 0.0050 nan 0.0500 -0.0000
60 0.0025 nan 0.0500 -0.0000
80 0.0015 nan 0.0500 0.0000
100 0.0009 nan 0.0500 -0.0000
120 0.0006 nan 0.0500 0.0000
140 0.0003 nan 0.0500 0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0002 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold25: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold25: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0365 nan 0.0500 0.0024
2 0.0339 nan 0.0500 0.0017
3 0.0320 nan 0.0500 0.0017
4 0.0307 nan 0.0500 0.0004
5 0.0288 nan 0.0500 0.0020
6 0.0266 nan 0.0500 0.0016
7 0.0251 nan 0.0500 0.0014
8 0.0236 nan 0.0500 0.0014
9 0.0225 nan 0.0500 0.0007
10 0.0216 nan 0.0500 0.0008
20 0.0143 nan 0.0500 0.0003
40 0.0076 nan 0.0500 0.0001
60 0.0050 nan 0.0500 0.0000
80 0.0035 nan 0.0500 -0.0000
100 0.0024 nan 0.0500 -0.0001
120 0.0016 nan 0.0500 -0.0000
140 0.0011 nan 0.0500 -0.0000
160 0.0009 nan 0.0500 -0.0000
180 0.0007 nan 0.0500 0.0000
200 0.0005 nan 0.0500 -0.0000
- Fold25: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold25: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0374 nan 0.0500 0.0021
2 0.0342 nan 0.0500 0.0016
3 0.0316 nan 0.0500 0.0017
4 0.0289 nan 0.0500 0.0017
5 0.0273 nan 0.0500 0.0013
6 0.0251 nan 0.0500 0.0007
7 0.0238 nan 0.0500 0.0003
8 0.0216 nan 0.0500 0.0019
9 0.0202 nan 0.0500 0.0011
10 0.0191 nan 0.0500 0.0008
20 0.0098 nan 0.0500 0.0005
40 0.0032 nan 0.0500 0.0000
60 0.0012 nan 0.0500 0.0000
80 0.0004 nan 0.0500 -0.0000
100 0.0002 nan 0.0500 0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0000 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold25: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold25: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0361 nan 0.0500 0.0030
2 0.0352 nan 0.0500 -0.0002
3 0.0324 nan 0.0500 0.0027
4 0.0294 nan 0.0500 0.0021
5 0.0273 nan 0.0500 0.0016
6 0.0252 nan 0.0500 0.0019
7 0.0235 nan 0.0500 0.0013
8 0.0215 nan 0.0500 0.0008
9 0.0198 nan 0.0500 0.0007
10 0.0186 nan 0.0500 0.0013
20 0.0111 nan 0.0500 0.0001
40 0.0038 nan 0.0500 0.0001
60 0.0020 nan 0.0500 0.0000
80 0.0011 nan 0.0500 -0.0000
100 0.0007 nan 0.0500 0.0000
120 0.0004 nan 0.0500 -0.0000
140 0.0003 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 0.0000
- Fold25: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold25: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0360 nan 0.0500 0.0022
2 0.0340 nan 0.0500 0.0012
3 0.0317 nan 0.0500 0.0022
4 0.0298 nan 0.0500 0.0017
5 0.0280 nan 0.0500 0.0019
6 0.0268 nan 0.0500 0.0009
7 0.0258 nan 0.0500 0.0006
8 0.0246 nan 0.0500 0.0012
9 0.0231 nan 0.0500 0.0011
10 0.0225 nan 0.0500 0.0003
20 0.0145 nan 0.0500 0.0003
40 0.0082 nan 0.0500 -0.0003
60 0.0051 nan 0.0500 0.0001
80 0.0030 nan 0.0500 -0.0001
100 0.0022 nan 0.0500 -0.0001
120 0.0016 nan 0.0500 0.0000
140 0.0012 nan 0.0500 -0.0001
160 0.0009 nan 0.0500 -0.0000
180 0.0007 nan 0.0500 -0.0000
200 0.0006 nan 0.0500 0.0000
- Fold25: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold25: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0363 nan 0.1000 0.0016
2 0.0313 nan 0.1000 0.0020
3 0.0281 nan 0.1000 0.0028
4 0.0239 nan 0.1000 0.0036
5 0.0224 nan 0.1000 0.0013
6 0.0199 nan 0.1000 0.0021
7 0.0179 nan 0.1000 -0.0002
8 0.0156 nan 0.1000 0.0004
9 0.0137 nan 0.1000 0.0003
10 0.0123 nan 0.1000 0.0012
20 0.0066 nan 0.1000 -0.0001
40 0.0017 nan 0.1000 -0.0000
60 0.0008 nan 0.1000 -0.0001
80 0.0004 nan 0.1000 -0.0000
100 0.0002 nan 0.1000 0.0000
120 0.0001 nan 0.1000 0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold25: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold25: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0344 nan 0.1000 0.0052
2 0.0308 nan 0.1000 0.0044
3 0.0267 nan 0.1000 0.0015
4 0.0242 nan 0.1000 0.0023
5 0.0225 nan 0.1000 0.0017
6 0.0198 nan 0.1000 0.0028
7 0.0188 nan 0.1000 -0.0004
8 0.0167 nan 0.1000 0.0012
9 0.0150 nan 0.1000 -0.0000
10 0.0137 nan 0.1000 0.0014
20 0.0062 nan 0.1000 0.0004
40 0.0022 nan 0.1000 -0.0000
60 0.0009 nan 0.1000 -0.0001
80 0.0004 nan 0.1000 -0.0000
100 0.0002 nan 0.1000 0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold25: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold25: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0335 nan 0.1000 0.0039
2 0.0299 nan 0.1000 0.0041
3 0.0272 nan 0.1000 0.0017
4 0.0255 nan 0.1000 0.0015
5 0.0220 nan 0.1000 0.0026
6 0.0200 nan 0.1000 0.0021
7 0.0186 nan 0.1000 0.0013
8 0.0173 nan 0.1000 0.0004
9 0.0158 nan 0.1000 0.0011
10 0.0152 nan 0.1000 0.0003
20 0.0088 nan 0.1000 0.0001
40 0.0035 nan 0.1000 0.0001
60 0.0014 nan 0.1000 -0.0001
80 0.0009 nan 0.1000 -0.0000
100 0.0005 nan 0.1000 -0.0000
120 0.0003 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold25: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold25: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0333 nan 0.1000 0.0063
2 0.0311 nan 0.1000 -0.0007
3 0.0271 nan 0.1000 0.0012
4 0.0236 nan 0.1000 0.0033
5 0.0210 nan 0.1000 0.0022
6 0.0191 nan 0.1000 0.0014
7 0.0171 nan 0.1000 0.0024
8 0.0154 nan 0.1000 0.0012
9 0.0136 nan 0.1000 0.0012
10 0.0119 nan 0.1000 0.0013
20 0.0045 nan 0.1000 0.0002
40 0.0008 nan 0.1000 -0.0000
60 0.0002 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold25: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold25: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0349 nan 0.1000 0.0016
2 0.0297 nan 0.1000 0.0044
3 0.0251 nan 0.1000 0.0024
4 0.0221 nan 0.1000 0.0013
5 0.0205 nan 0.1000 0.0011
6 0.0191 nan 0.1000 0.0001
7 0.0163 nan 0.1000 0.0025
8 0.0137 nan 0.1000 0.0021
9 0.0121 nan 0.1000 0.0013
10 0.0109 nan 0.1000 0.0005
20 0.0037 nan 0.1000 0.0002
40 0.0010 nan 0.1000 -0.0000
60 0.0004 nan 0.1000 0.0000
80 0.0002 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 0.0000
180 0.0000 nan 0.1000 0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold25: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold25: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0338 nan 0.1000 0.0049
2 0.0303 nan 0.1000 0.0029
3 0.0275 nan 0.1000 0.0030
4 0.0238 nan 0.1000 0.0026
5 0.0206 nan 0.1000 0.0022
6 0.0183 nan 0.1000 0.0005
7 0.0172 nan 0.1000 0.0006
8 0.0157 nan 0.1000 0.0007
9 0.0144 nan 0.1000 0.0005
10 0.0130 nan 0.1000 0.0013
20 0.0069 nan 0.1000 0.0003
40 0.0032 nan 0.1000 0.0000
60 0.0018 nan 0.1000 -0.0001
80 0.0010 nan 0.1000 -0.0000
100 0.0006 nan 0.1000 0.0000
120 0.0004 nan 0.1000 0.0000
140 0.0003 nan 0.1000 0.0000
160 0.0002 nan 0.1000 0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold25: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold25: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0337 nan 0.1000 0.0037
2 0.0288 nan 0.1000 0.0045
3 0.0252 nan 0.1000 0.0019
4 0.0234 nan 0.1000 0.0021
5 0.0212 nan 0.1000 0.0011
6 0.0172 nan 0.1000 0.0017
7 0.0145 nan 0.1000 0.0002
8 0.0132 nan 0.1000 0.0006
9 0.0111 nan 0.1000 0.0006
10 0.0092 nan 0.1000 0.0009
20 0.0035 nan 0.1000 0.0003
40 0.0005 nan 0.1000 -0.0000
60 0.0001 nan 0.1000 -0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 0.0000
120 0.0000 nan 0.1000 0.0000
140 0.0000 nan 0.1000 0.0000
160 0.0000 nan 0.1000 0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold25: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold25: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0339 nan 0.1000 0.0026
2 0.0279 nan 0.1000 0.0048
3 0.0240 nan 0.1000 0.0036
4 0.0230 nan 0.1000 -0.0015
5 0.0200 nan 0.1000 0.0022
6 0.0163 nan 0.1000 0.0010
7 0.0141 nan 0.1000 0.0004
8 0.0129 nan 0.1000 -0.0001
9 0.0115 nan 0.1000 0.0011
10 0.0107 nan 0.1000 0.0002
20 0.0038 nan 0.1000 0.0002
40 0.0010 nan 0.1000 -0.0001
60 0.0003 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold25: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold25: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0342 nan 0.1000 0.0053
2 0.0308 nan 0.1000 0.0030
3 0.0272 nan 0.1000 0.0032
4 0.0242 nan 0.1000 0.0031
5 0.0217 nan 0.1000 0.0021
6 0.0193 nan 0.1000 0.0023
7 0.0180 nan 0.1000 0.0010
8 0.0162 nan 0.1000 0.0017
9 0.0154 nan 0.1000 0.0005
10 0.0139 nan 0.1000 0.0011
20 0.0081 nan 0.1000 0.0004
40 0.0038 nan 0.1000 -0.0003
60 0.0020 nan 0.1000 0.0000
80 0.0009 nan 0.1000 -0.0000
100 0.0006 nan 0.1000 -0.0000
120 0.0003 nan 0.1000 0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0002 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold25: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold26: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0435 nan 0.0100 0.0002
2 0.0429 nan 0.0100 0.0003
3 0.0425 nan 0.0100 0.0002
4 0.0417 nan 0.0100 0.0006
5 0.0413 nan 0.0100 0.0004
6 0.0408 nan 0.0100 0.0001
7 0.0403 nan 0.0100 0.0005
8 0.0397 nan 0.0100 0.0003
9 0.0393 nan 0.0100 0.0001
10 0.0388 nan 0.0100 0.0003
20 0.0343 nan 0.0100 0.0004
40 0.0275 nan 0.0100 0.0002
60 0.0222 nan 0.0100 0.0002
80 0.0181 nan 0.0100 0.0001
100 0.0148 nan 0.0100 0.0002
120 0.0122 nan 0.0100 0.0001
140 0.0104 nan 0.0100 -0.0000
160 0.0086 nan 0.0100 0.0000
180 0.0074 nan 0.0100 0.0000
200 0.0064 nan 0.0100 0.0000
- Fold26: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold26: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0433 nan 0.0100 0.0005
2 0.0428 nan 0.0100 0.0005
3 0.0422 nan 0.0100 0.0005
4 0.0416 nan 0.0100 0.0005
5 0.0413 nan 0.0100 0.0003
6 0.0407 nan 0.0100 0.0004
7 0.0402 nan 0.0100 0.0005
8 0.0397 nan 0.0100 0.0005
9 0.0391 nan 0.0100 0.0005
10 0.0386 nan 0.0100 0.0002
20 0.0345 nan 0.0100 0.0005
40 0.0273 nan 0.0100 0.0004
60 0.0221 nan 0.0100 0.0001
80 0.0178 nan 0.0100 0.0002
100 0.0150 nan 0.0100 0.0001
120 0.0124 nan 0.0100 0.0000
140 0.0105 nan 0.0100 0.0001
160 0.0089 nan 0.0100 0.0000
180 0.0075 nan 0.0100 0.0000
200 0.0065 nan 0.0100 0.0000
- Fold26: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold26: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0435 nan 0.0100 0.0001
2 0.0429 nan 0.0100 0.0003
3 0.0427 nan 0.0100 -0.0001
4 0.0422 nan 0.0100 0.0003
5 0.0416 nan 0.0100 0.0005
6 0.0411 nan 0.0100 0.0003
7 0.0406 nan 0.0100 0.0002
8 0.0399 nan 0.0100 0.0006
9 0.0394 nan 0.0100 0.0004
10 0.0389 nan 0.0100 0.0003
20 0.0349 nan 0.0100 0.0001
40 0.0277 nan 0.0100 0.0003
60 0.0222 nan 0.0100 0.0003
80 0.0188 nan 0.0100 0.0002
100 0.0156 nan 0.0100 -0.0000
120 0.0133 nan 0.0100 0.0000
140 0.0116 nan 0.0100 0.0001
160 0.0101 nan 0.0100 0.0000
180 0.0089 nan 0.0100 -0.0001
200 0.0079 nan 0.0100 0.0000
- Fold26: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold26: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0433 nan 0.0100 0.0005
2 0.0427 nan 0.0100 0.0003
3 0.0424 nan 0.0100 0.0003
4 0.0421 nan 0.0100 0.0003
5 0.0418 nan 0.0100 0.0001
6 0.0412 nan 0.0100 0.0006
7 0.0405 nan 0.0100 0.0008
8 0.0401 nan 0.0100 0.0003
9 0.0398 nan 0.0100 0.0001
10 0.0394 nan 0.0100 0.0002
20 0.0338 nan 0.0100 0.0003
40 0.0264 nan 0.0100 0.0000
60 0.0201 nan 0.0100 -0.0002
80 0.0155 nan 0.0100 0.0001
100 0.0121 nan 0.0100 0.0001
120 0.0093 nan 0.0100 0.0001
140 0.0074 nan 0.0100 0.0001
160 0.0058 nan 0.0100 0.0000
180 0.0049 nan 0.0100 -0.0000
200 0.0041 nan 0.0100 0.0000
- Fold26: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold26: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0432 nan 0.0100 0.0003
2 0.0426 nan 0.0100 0.0002
3 0.0420 nan 0.0100 0.0006
4 0.0413 nan 0.0100 0.0006
5 0.0408 nan 0.0100 0.0006
6 0.0400 nan 0.0100 0.0004
7 0.0395 nan 0.0100 0.0004
8 0.0388 nan 0.0100 0.0004
9 0.0384 nan 0.0100 0.0005
10 0.0379 nan 0.0100 0.0005
20 0.0332 nan 0.0100 0.0005
40 0.0254 nan 0.0100 0.0002
60 0.0195 nan 0.0100 0.0003
80 0.0151 nan 0.0100 0.0002
100 0.0121 nan 0.0100 0.0001
120 0.0097 nan 0.0100 0.0000
140 0.0079 nan 0.0100 0.0001
160 0.0064 nan 0.0100 0.0000
180 0.0052 nan 0.0100 -0.0000
200 0.0043 nan 0.0100 0.0000
- Fold26: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold26: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0435 nan 0.0100 0.0004
2 0.0429 nan 0.0100 0.0006
3 0.0423 nan 0.0100 0.0005
4 0.0419 nan 0.0100 -0.0000
5 0.0416 nan 0.0100 0.0004
6 0.0412 nan 0.0100 0.0004
7 0.0407 nan 0.0100 0.0004
8 0.0401 nan 0.0100 0.0005
9 0.0397 nan 0.0100 0.0004
10 0.0393 nan 0.0100 0.0004
20 0.0351 nan 0.0100 0.0004
40 0.0287 nan 0.0100 0.0002
60 0.0236 nan 0.0100 0.0002
80 0.0197 nan 0.0100 0.0001
100 0.0168 nan 0.0100 0.0002
120 0.0140 nan 0.0100 0.0000
140 0.0120 nan 0.0100 -0.0000
160 0.0105 nan 0.0100 -0.0000
180 0.0092 nan 0.0100 0.0001
200 0.0082 nan 0.0100 0.0001
- Fold26: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold26: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0432 nan 0.0100 0.0004
2 0.0424 nan 0.0100 0.0007
3 0.0418 nan 0.0100 0.0004
4 0.0411 nan 0.0100 0.0007
5 0.0402 nan 0.0100 0.0006
6 0.0395 nan 0.0100 0.0004
7 0.0389 nan 0.0100 0.0006
8 0.0381 nan 0.0100 0.0006
9 0.0376 nan 0.0100 0.0002
10 0.0371 nan 0.0100 0.0003
20 0.0320 nan 0.0100 0.0002
40 0.0240 nan 0.0100 0.0003
60 0.0179 nan 0.0100 0.0002
80 0.0142 nan 0.0100 -0.0000
100 0.0110 nan 0.0100 0.0001
120 0.0085 nan 0.0100 0.0001
140 0.0064 nan 0.0100 0.0000
160 0.0051 nan 0.0100 0.0000
180 0.0041 nan 0.0100 0.0000
200 0.0033 nan 0.0100 0.0000
- Fold26: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold26: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0431 nan 0.0100 0.0006
2 0.0428 nan 0.0100 -0.0002
3 0.0423 nan 0.0100 0.0002
4 0.0416 nan 0.0100 0.0006
5 0.0410 nan 0.0100 0.0005
6 0.0405 nan 0.0100 0.0005
7 0.0398 nan 0.0100 0.0006
8 0.0391 nan 0.0100 0.0005
9 0.0385 nan 0.0100 0.0004
10 0.0382 nan 0.0100 0.0001
20 0.0334 nan 0.0100 0.0005
40 0.0251 nan 0.0100 0.0004
60 0.0196 nan 0.0100 0.0001
80 0.0152 nan 0.0100 0.0001
100 0.0117 nan 0.0100 0.0001
120 0.0093 nan 0.0100 0.0001
140 0.0073 nan 0.0100 0.0001
160 0.0060 nan 0.0100 0.0000
180 0.0050 nan 0.0100 0.0000
200 0.0041 nan 0.0100 0.0000
- Fold26: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold26: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0434 nan 0.0100 0.0003
2 0.0428 nan 0.0100 0.0005
3 0.0422 nan 0.0100 0.0006
4 0.0417 nan 0.0100 0.0005
5 0.0410 nan 0.0100 0.0004
6 0.0404 nan 0.0100 0.0005
7 0.0399 nan 0.0100 0.0003
8 0.0395 nan 0.0100 0.0004
9 0.0390 nan 0.0100 0.0005
10 0.0386 nan 0.0100 0.0001
20 0.0344 nan 0.0100 -0.0000
40 0.0275 nan 0.0100 0.0003
60 0.0227 nan 0.0100 0.0003
80 0.0184 nan 0.0100 0.0002
100 0.0153 nan 0.0100 0.0002
120 0.0132 nan 0.0100 0.0001
140 0.0114 nan 0.0100 0.0001
160 0.0098 nan 0.0100 0.0000
180 0.0087 nan 0.0100 -0.0001
200 0.0077 nan 0.0100 0.0000
- Fold26: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold26: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0412 nan 0.0500 0.0027
2 0.0390 nan 0.0500 0.0026
3 0.0360 nan 0.0500 0.0026
4 0.0338 nan 0.0500 0.0019
5 0.0316 nan 0.0500 0.0014
6 0.0293 nan 0.0500 0.0018
7 0.0280 nan 0.0500 0.0011
8 0.0266 nan 0.0500 0.0015
9 0.0250 nan 0.0500 0.0010
10 0.0236 nan 0.0500 0.0013
20 0.0136 nan 0.0500 0.0003
40 0.0053 nan 0.0500 0.0000
60 0.0027 nan 0.0500 0.0000
80 0.0012 nan 0.0500 0.0000
100 0.0006 nan 0.0500 0.0000
120 0.0004 nan 0.0500 -0.0000
140 0.0002 nan 0.0500 -0.0000
160 0.0001 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold26: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold26: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0419 nan 0.0500 0.0003
2 0.0388 nan 0.0500 0.0027
3 0.0372 nan 0.0500 0.0019
4 0.0355 nan 0.0500 0.0019
5 0.0334 nan 0.0500 0.0020
6 0.0319 nan 0.0500 0.0019
7 0.0302 nan 0.0500 0.0014
8 0.0287 nan 0.0500 0.0015
9 0.0269 nan 0.0500 0.0014
10 0.0259 nan 0.0500 0.0007
20 0.0161 nan 0.0500 0.0004
40 0.0072 nan 0.0500 0.0001
60 0.0039 nan 0.0500 -0.0000
80 0.0024 nan 0.0500 0.0001
100 0.0015 nan 0.0500 0.0000
120 0.0010 nan 0.0500 -0.0000
140 0.0007 nan 0.0500 0.0000
160 0.0004 nan 0.0500 -0.0000
180 0.0003 nan 0.0500 0.0000
200 0.0002 nan 0.0500 -0.0000
- Fold26: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold26: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0417 nan 0.0500 -0.0004
2 0.0385 nan 0.0500 0.0021
3 0.0362 nan 0.0500 0.0023
4 0.0344 nan 0.0500 0.0013
5 0.0317 nan 0.0500 0.0022
6 0.0300 nan 0.0500 0.0017
7 0.0285 nan 0.0500 0.0007
8 0.0267 nan 0.0500 0.0013
9 0.0254 nan 0.0500 0.0010
10 0.0246 nan 0.0500 0.0006
20 0.0150 nan 0.0500 0.0004
40 0.0089 nan 0.0500 -0.0001
60 0.0058 nan 0.0500 -0.0000
80 0.0036 nan 0.0500 -0.0000
100 0.0026 nan 0.0500 0.0000
120 0.0020 nan 0.0500 -0.0000
140 0.0015 nan 0.0500 -0.0000
160 0.0011 nan 0.0500 -0.0000
180 0.0008 nan 0.0500 -0.0000
200 0.0006 nan 0.0500 -0.0000
- Fold26: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold26: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0398 nan 0.0500 0.0045
2 0.0365 nan 0.0500 0.0011
3 0.0338 nan 0.0500 0.0016
4 0.0315 nan 0.0500 0.0023
5 0.0292 nan 0.0500 0.0016
6 0.0266 nan 0.0500 0.0013
7 0.0255 nan 0.0500 0.0007
8 0.0238 nan 0.0500 0.0018
9 0.0228 nan 0.0500 0.0008
10 0.0212 nan 0.0500 0.0012
20 0.0122 nan 0.0500 0.0009
40 0.0042 nan 0.0500 0.0001
60 0.0014 nan 0.0500 0.0001
80 0.0007 nan 0.0500 0.0000
100 0.0003 nan 0.0500 0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0001 nan 0.0500 0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 0.0000
- Fold26: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold26: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0405 nan 0.0500 0.0023
2 0.0378 nan 0.0500 0.0021
3 0.0368 nan 0.0500 0.0002
4 0.0339 nan 0.0500 0.0025
5 0.0317 nan 0.0500 0.0004
6 0.0293 nan 0.0500 0.0007
7 0.0270 nan 0.0500 0.0016
8 0.0251 nan 0.0500 0.0011
9 0.0232 nan 0.0500 0.0012
10 0.0214 nan 0.0500 0.0015
20 0.0120 nan 0.0500 0.0001
40 0.0047 nan 0.0500 0.0000
60 0.0018 nan 0.0500 0.0000
80 0.0008 nan 0.0500 0.0000
100 0.0005 nan 0.0500 -0.0000
120 0.0003 nan 0.0500 -0.0000
140 0.0002 nan 0.0500 0.0000
160 0.0001 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 0.0000
- Fold26: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold26: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0408 nan 0.0500 0.0027
2 0.0385 nan 0.0500 0.0022
3 0.0379 nan 0.0500 -0.0005
4 0.0363 nan 0.0500 0.0014
5 0.0342 nan 0.0500 0.0021
6 0.0332 nan 0.0500 0.0007
7 0.0308 nan 0.0500 0.0018
8 0.0295 nan 0.0500 0.0006
9 0.0281 nan 0.0500 0.0010
10 0.0264 nan 0.0500 0.0007
20 0.0165 nan 0.0500 0.0008
40 0.0082 nan 0.0500 0.0002
60 0.0042 nan 0.0500 0.0000
80 0.0028 nan 0.0500 -0.0001
100 0.0017 nan 0.0500 -0.0000
120 0.0013 nan 0.0500 -0.0000
140 0.0009 nan 0.0500 0.0000
160 0.0007 nan 0.0500 -0.0000
180 0.0005 nan 0.0500 -0.0000
200 0.0004 nan 0.0500 0.0000
- Fold26: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold26: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0420 nan 0.0500 0.0012
2 0.0402 nan 0.0500 0.0018
3 0.0385 nan 0.0500 -0.0002
4 0.0359 nan 0.0500 0.0014
5 0.0338 nan 0.0500 0.0001
6 0.0321 nan 0.0500 0.0004
7 0.0290 nan 0.0500 0.0032
8 0.0279 nan 0.0500 -0.0010
9 0.0253 nan 0.0500 0.0026
10 0.0233 nan 0.0500 0.0018
20 0.0114 nan 0.0500 0.0006
40 0.0031 nan 0.0500 0.0001
60 0.0011 nan 0.0500 -0.0001
80 0.0004 nan 0.0500 -0.0000
100 0.0002 nan 0.0500 -0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0000 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 0.0000
180 0.0000 nan 0.0500 0.0000
200 0.0000 nan 0.0500 0.0000
- Fold26: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold26: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0424 nan 0.0500 -0.0001
2 0.0405 nan 0.0500 0.0013
3 0.0382 nan 0.0500 0.0022
4 0.0369 nan 0.0500 0.0005
5 0.0343 nan 0.0500 0.0015
6 0.0325 nan 0.0500 0.0020
7 0.0308 nan 0.0500 0.0009
8 0.0288 nan 0.0500 0.0016
9 0.0269 nan 0.0500 0.0019
10 0.0249 nan 0.0500 0.0019
20 0.0133 nan 0.0500 0.0007
40 0.0051 nan 0.0500 -0.0000
60 0.0026 nan 0.0500 0.0000
80 0.0012 nan 0.0500 -0.0000
100 0.0007 nan 0.0500 -0.0000
120 0.0004 nan 0.0500 -0.0000
140 0.0003 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold26: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold26: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0422 nan 0.0500 0.0014
2 0.0393 nan 0.0500 0.0030
3 0.0366 nan 0.0500 0.0025
4 0.0337 nan 0.0500 0.0021
5 0.0325 nan 0.0500 0.0008
6 0.0306 nan 0.0500 0.0008
7 0.0289 nan 0.0500 0.0017
8 0.0281 nan 0.0500 0.0003
9 0.0263 nan 0.0500 0.0015
10 0.0251 nan 0.0500 0.0014
20 0.0160 nan 0.0500 0.0002
40 0.0079 nan 0.0500 0.0003
60 0.0046 nan 0.0500 0.0001
80 0.0029 nan 0.0500 -0.0000
100 0.0021 nan 0.0500 -0.0000
120 0.0015 nan 0.0500 -0.0000
140 0.0011 nan 0.0500 -0.0000
160 0.0008 nan 0.0500 -0.0000
180 0.0006 nan 0.0500 -0.0000
200 0.0005 nan 0.0500 -0.0000
- Fold26: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold26: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0380 nan 0.1000 0.0058
2 0.0330 nan 0.1000 0.0036
3 0.0306 nan 0.1000 0.0023
4 0.0270 nan 0.1000 0.0003
5 0.0246 nan 0.1000 0.0026
6 0.0219 nan 0.1000 0.0019
7 0.0199 nan 0.1000 0.0022
8 0.0183 nan 0.1000 0.0004
9 0.0166 nan 0.1000 0.0012
10 0.0145 nan 0.1000 0.0019
20 0.0067 nan 0.1000 0.0003
40 0.0016 nan 0.1000 -0.0001
60 0.0006 nan 0.1000 0.0000
80 0.0002 nan 0.1000 0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold26: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold26: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0377 nan 0.1000 0.0047
2 0.0325 nan 0.1000 0.0049
3 0.0289 nan 0.1000 0.0011
4 0.0257 nan 0.1000 0.0017
5 0.0229 nan 0.1000 0.0030
6 0.0203 nan 0.1000 -0.0001
7 0.0181 nan 0.1000 0.0012
8 0.0157 nan 0.1000 0.0021
9 0.0141 nan 0.1000 0.0008
10 0.0126 nan 0.1000 0.0001
20 0.0053 nan 0.1000 0.0002
40 0.0017 nan 0.1000 -0.0001
60 0.0008 nan 0.1000 -0.0000
80 0.0004 nan 0.1000 0.0000
100 0.0002 nan 0.1000 -0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 0.0000
- Fold26: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold26: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0381 nan 0.1000 0.0048
2 0.0322 nan 0.1000 0.0038
3 0.0289 nan 0.1000 0.0024
4 0.0258 nan 0.1000 0.0034
5 0.0232 nan 0.1000 0.0016
6 0.0205 nan 0.1000 0.0023
7 0.0189 nan 0.1000 0.0010
8 0.0177 nan 0.1000 0.0011
9 0.0169 nan 0.1000 0.0006
10 0.0153 nan 0.1000 0.0007
20 0.0070 nan 0.1000 0.0002
40 0.0032 nan 0.1000 -0.0000
60 0.0013 nan 0.1000 -0.0000
80 0.0007 nan 0.1000 -0.0000
100 0.0003 nan 0.1000 -0.0000
120 0.0002 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold26: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold26: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0379 nan 0.1000 0.0046
2 0.0324 nan 0.1000 0.0021
3 0.0272 nan 0.1000 0.0043
4 0.0242 nan 0.1000 0.0030
5 0.0217 nan 0.1000 0.0021
6 0.0182 nan 0.1000 0.0018
7 0.0161 nan 0.1000 0.0006
8 0.0134 nan 0.1000 0.0019
9 0.0115 nan 0.1000 0.0019
10 0.0103 nan 0.1000 0.0006
20 0.0031 nan 0.1000 0.0002
40 0.0006 nan 0.1000 -0.0001
60 0.0002 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold26: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold26: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0377 nan 0.1000 0.0066
2 0.0325 nan 0.1000 0.0053
3 0.0290 nan 0.1000 0.0026
4 0.0264 nan 0.1000 0.0023
5 0.0237 nan 0.1000 0.0020
6 0.0222 nan 0.1000 -0.0004
7 0.0191 nan 0.1000 0.0007
8 0.0177 nan 0.1000 -0.0002
9 0.0152 nan 0.1000 0.0016
10 0.0143 nan 0.1000 -0.0005
20 0.0051 nan 0.1000 0.0004
40 0.0012 nan 0.1000 0.0000
60 0.0004 nan 0.1000 -0.0000
80 0.0002 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold26: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold26: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0383 nan 0.1000 0.0052
2 0.0326 nan 0.1000 0.0045
3 0.0284 nan 0.1000 0.0039
4 0.0259 nan 0.1000 0.0011
5 0.0237 nan 0.1000 0.0012
6 0.0223 nan 0.1000 0.0003
7 0.0205 nan 0.1000 0.0012
8 0.0200 nan 0.1000 -0.0020
9 0.0179 nan 0.1000 0.0016
10 0.0167 nan 0.1000 0.0006
20 0.0084 nan 0.1000 0.0004
40 0.0030 nan 0.1000 -0.0000
60 0.0013 nan 0.1000 -0.0001
80 0.0007 nan 0.1000 0.0000
100 0.0004 nan 0.1000 -0.0000
120 0.0003 nan 0.1000 0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold26: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold26: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0365 nan 0.1000 0.0052
2 0.0313 nan 0.1000 0.0052
3 0.0283 nan 0.1000 0.0021
4 0.0244 nan 0.1000 0.0024
5 0.0210 nan 0.1000 0.0028
6 0.0203 nan 0.1000 -0.0005
7 0.0174 nan 0.1000 0.0031
8 0.0152 nan 0.1000 0.0015
9 0.0137 nan 0.1000 0.0018
10 0.0118 nan 0.1000 0.0016
20 0.0036 nan 0.1000 0.0001
40 0.0005 nan 0.1000 0.0000
60 0.0001 nan 0.1000 -0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 0.0000
- Fold26: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold26: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0378 nan 0.1000 0.0049
2 0.0315 nan 0.1000 0.0018
3 0.0271 nan 0.1000 0.0017
4 0.0236 nan 0.1000 0.0019
5 0.0209 nan 0.1000 0.0022
6 0.0178 nan 0.1000 0.0024
7 0.0154 nan 0.1000 0.0020
8 0.0137 nan 0.1000 0.0004
9 0.0119 nan 0.1000 0.0003
10 0.0103 nan 0.1000 0.0011
20 0.0044 nan 0.1000 0.0003
40 0.0010 nan 0.1000 0.0000
60 0.0003 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold26: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold26: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0391 nan 0.1000 0.0034
2 0.0338 nan 0.1000 0.0043
3 0.0299 nan 0.1000 0.0036
4 0.0254 nan 0.1000 0.0027
5 0.0231 nan 0.1000 0.0024
6 0.0203 nan 0.1000 0.0019
7 0.0179 nan 0.1000 0.0015
8 0.0167 nan 0.1000 0.0010
9 0.0152 nan 0.1000 0.0011
10 0.0139 nan 0.1000 0.0009
20 0.0083 nan 0.1000 -0.0002
40 0.0037 nan 0.1000 0.0001
60 0.0022 nan 0.1000 -0.0001
80 0.0013 nan 0.1000 -0.0001
100 0.0008 nan 0.1000 -0.0000
120 0.0005 nan 0.1000 0.0000
140 0.0004 nan 0.1000 -0.0000
160 0.0002 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold26: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold27: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0439 nan 0.0100 0.0002
2 0.0433 nan 0.0100 0.0005
3 0.0427 nan 0.0100 0.0004
4 0.0422 nan 0.0100 0.0004
5 0.0415 nan 0.0100 0.0006
6 0.0412 nan 0.0100 -0.0001
7 0.0406 nan 0.0100 0.0006
8 0.0403 nan 0.0100 0.0000
9 0.0399 nan 0.0100 0.0004
10 0.0394 nan 0.0100 0.0003
20 0.0351 nan 0.0100 0.0003
40 0.0280 nan 0.0100 0.0004
60 0.0222 nan 0.0100 0.0001
80 0.0179 nan 0.0100 -0.0000
100 0.0148 nan 0.0100 0.0000
120 0.0123 nan 0.0100 0.0001
140 0.0101 nan 0.0100 0.0001
160 0.0086 nan 0.0100 0.0000
180 0.0073 nan 0.0100 -0.0000
200 0.0061 nan 0.0100 0.0000
- Fold27: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold27: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0436 nan 0.0100 0.0006
2 0.0429 nan 0.0100 0.0006
3 0.0425 nan 0.0100 0.0003
4 0.0418 nan 0.0100 0.0006
5 0.0413 nan 0.0100 0.0005
6 0.0407 nan 0.0100 0.0006
7 0.0401 nan 0.0100 0.0005
8 0.0397 nan 0.0100 0.0002
9 0.0394 nan 0.0100 0.0002
10 0.0389 nan 0.0100 0.0002
20 0.0348 nan 0.0100 0.0000
40 0.0275 nan 0.0100 0.0002
60 0.0226 nan 0.0100 0.0001
80 0.0186 nan 0.0100 0.0001
100 0.0150 nan 0.0100 0.0001
120 0.0124 nan 0.0100 0.0001
140 0.0103 nan 0.0100 0.0000
160 0.0086 nan 0.0100 0.0001
180 0.0072 nan 0.0100 0.0000
200 0.0061 nan 0.0100 0.0000
- Fold27: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold27: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0437 nan 0.0100 0.0006
2 0.0430 nan 0.0100 0.0005
3 0.0425 nan 0.0100 0.0005
4 0.0419 nan 0.0100 0.0006
5 0.0413 nan 0.0100 0.0004
6 0.0409 nan 0.0100 0.0004
7 0.0404 nan 0.0100 0.0003
8 0.0399 nan 0.0100 0.0005
9 0.0394 nan 0.0100 0.0004
10 0.0389 nan 0.0100 0.0002
20 0.0346 nan 0.0100 0.0005
40 0.0276 nan 0.0100 0.0002
60 0.0227 nan 0.0100 0.0002
80 0.0187 nan 0.0100 0.0001
100 0.0158 nan 0.0100 0.0001
120 0.0137 nan 0.0100 0.0001
140 0.0121 nan 0.0100 0.0000
160 0.0106 nan 0.0100 0.0000
180 0.0095 nan 0.0100 -0.0000
200 0.0085 nan 0.0100 0.0000
- Fold27: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold27: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0434 nan 0.0100 0.0008
2 0.0427 nan 0.0100 0.0005
3 0.0422 nan 0.0100 0.0003
4 0.0415 nan 0.0100 0.0009
5 0.0409 nan 0.0100 0.0005
6 0.0403 nan 0.0100 0.0005
7 0.0397 nan 0.0100 0.0003
8 0.0392 nan 0.0100 0.0002
9 0.0390 nan 0.0100 -0.0001
10 0.0383 nan 0.0100 0.0008
20 0.0329 nan 0.0100 0.0005
40 0.0246 nan 0.0100 0.0002
60 0.0191 nan 0.0100 0.0003
80 0.0147 nan 0.0100 0.0001
100 0.0116 nan 0.0100 0.0001
120 0.0093 nan 0.0100 0.0001
140 0.0075 nan 0.0100 0.0000
160 0.0061 nan 0.0100 0.0000
180 0.0049 nan 0.0100 0.0000
200 0.0039 nan 0.0100 0.0000
- Fold27: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold27: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0438 nan 0.0100 0.0002
2 0.0431 nan 0.0100 0.0005
3 0.0426 nan 0.0100 0.0005
4 0.0419 nan 0.0100 0.0007
5 0.0416 nan 0.0100 -0.0001
6 0.0409 nan 0.0100 0.0005
7 0.0402 nan 0.0100 0.0006
8 0.0397 nan 0.0100 0.0001
9 0.0391 nan 0.0100 0.0006
10 0.0386 nan 0.0100 0.0004
20 0.0337 nan 0.0100 0.0003
40 0.0255 nan 0.0100 0.0002
60 0.0204 nan 0.0100 0.0002
80 0.0164 nan 0.0100 0.0001
100 0.0129 nan 0.0100 0.0001
120 0.0103 nan 0.0100 0.0001
140 0.0082 nan 0.0100 0.0000
160 0.0068 nan 0.0100 0.0001
180 0.0055 nan 0.0100 0.0000
200 0.0046 nan 0.0100 -0.0000
- Fold27: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold27: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0438 nan 0.0100 0.0005
2 0.0431 nan 0.0100 0.0006
3 0.0426 nan 0.0100 0.0005
4 0.0423 nan 0.0100 0.0003
5 0.0418 nan 0.0100 0.0003
6 0.0415 nan 0.0100 0.0000
7 0.0412 nan 0.0100 0.0001
8 0.0407 nan 0.0100 0.0004
9 0.0402 nan 0.0100 0.0005
10 0.0398 nan 0.0100 0.0003
20 0.0353 nan 0.0100 0.0003
40 0.0283 nan 0.0100 0.0003
60 0.0231 nan 0.0100 0.0003
80 0.0194 nan 0.0100 -0.0000
100 0.0164 nan 0.0100 0.0000
120 0.0140 nan 0.0100 0.0001
140 0.0120 nan 0.0100 0.0000
160 0.0105 nan 0.0100 0.0000
180 0.0093 nan 0.0100 -0.0001
200 0.0082 nan 0.0100 0.0000
- Fold27: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold27: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0437 nan 0.0100 0.0005
2 0.0429 nan 0.0100 0.0009
3 0.0422 nan 0.0100 0.0006
4 0.0414 nan 0.0100 0.0005
5 0.0406 nan 0.0100 0.0006
6 0.0400 nan 0.0100 0.0005
7 0.0394 nan 0.0100 0.0006
8 0.0390 nan 0.0100 -0.0001
9 0.0385 nan 0.0100 0.0004
10 0.0378 nan 0.0100 0.0005
20 0.0328 nan 0.0100 0.0000
40 0.0248 nan 0.0100 0.0003
60 0.0185 nan 0.0100 0.0001
80 0.0140 nan 0.0100 0.0001
100 0.0106 nan 0.0100 0.0001
120 0.0083 nan 0.0100 -0.0000
140 0.0064 nan 0.0100 -0.0000
160 0.0051 nan 0.0100 0.0000
180 0.0040 nan 0.0100 -0.0000
200 0.0032 nan 0.0100 0.0000
- Fold27: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold27: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0436 nan 0.0100 0.0007
2 0.0430 nan 0.0100 0.0005
3 0.0423 nan 0.0100 0.0007
4 0.0418 nan 0.0100 0.0004
5 0.0415 nan 0.0100 0.0001
6 0.0409 nan 0.0100 0.0005
7 0.0402 nan 0.0100 0.0006
8 0.0396 nan 0.0100 0.0005
9 0.0391 nan 0.0100 0.0004
10 0.0386 nan 0.0100 0.0004
20 0.0333 nan 0.0100 0.0003
40 0.0253 nan 0.0100 0.0002
60 0.0190 nan 0.0100 0.0003
80 0.0147 nan 0.0100 0.0002
100 0.0119 nan 0.0100 0.0001
120 0.0093 nan 0.0100 0.0001
140 0.0075 nan 0.0100 0.0000
160 0.0061 nan 0.0100 0.0000
180 0.0048 nan 0.0100 0.0000
200 0.0039 nan 0.0100 0.0000
- Fold27: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold27: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0437 nan 0.0100 0.0004
2 0.0433 nan 0.0100 0.0001
3 0.0426 nan 0.0100 0.0006
4 0.0421 nan 0.0100 0.0005
5 0.0415 nan 0.0100 0.0005
6 0.0410 nan 0.0100 0.0006
7 0.0404 nan 0.0100 0.0004
8 0.0398 nan 0.0100 0.0005
9 0.0397 nan 0.0100 -0.0003
10 0.0392 nan 0.0100 0.0005
20 0.0345 nan 0.0100 0.0004
40 0.0277 nan 0.0100 0.0001
60 0.0227 nan 0.0100 0.0002
80 0.0190 nan 0.0100 0.0000
100 0.0162 nan 0.0100 0.0001
120 0.0138 nan 0.0100 0.0001
140 0.0118 nan 0.0100 0.0001
160 0.0102 nan 0.0100 0.0001
180 0.0091 nan 0.0100 0.0000
200 0.0081 nan 0.0100 0.0000
- Fold27: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold27: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0406 nan 0.0500 0.0028
2 0.0381 nan 0.0500 0.0027
3 0.0352 nan 0.0500 0.0020
4 0.0325 nan 0.0500 0.0027
5 0.0299 nan 0.0500 0.0015
6 0.0285 nan 0.0500 0.0012
7 0.0271 nan 0.0500 0.0011
8 0.0254 nan 0.0500 0.0014
9 0.0231 nan 0.0500 0.0020
10 0.0224 nan 0.0500 0.0002
20 0.0137 nan 0.0500 0.0005
40 0.0050 nan 0.0500 0.0000
60 0.0025 nan 0.0500 -0.0000
80 0.0014 nan 0.0500 -0.0000
100 0.0007 nan 0.0500 0.0000
120 0.0005 nan 0.0500 -0.0000
140 0.0003 nan 0.0500 -0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold27: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold27: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0412 nan 0.0500 0.0024
2 0.0383 nan 0.0500 0.0029
3 0.0359 nan 0.0500 0.0019
4 0.0343 nan 0.0500 0.0019
5 0.0326 nan 0.0500 0.0008
6 0.0307 nan 0.0500 0.0016
7 0.0289 nan 0.0500 0.0015
8 0.0275 nan 0.0500 0.0012
9 0.0268 nan 0.0500 -0.0000
10 0.0254 nan 0.0500 0.0016
20 0.0151 nan 0.0500 0.0005
40 0.0059 nan 0.0500 0.0001
60 0.0031 nan 0.0500 -0.0000
80 0.0017 nan 0.0500 -0.0000
100 0.0009 nan 0.0500 -0.0000
120 0.0006 nan 0.0500 -0.0000
140 0.0004 nan 0.0500 -0.0000
160 0.0003 nan 0.0500 -0.0000
180 0.0002 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold27: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold27: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0418 nan 0.0500 0.0022
2 0.0389 nan 0.0500 0.0023
3 0.0364 nan 0.0500 0.0024
4 0.0340 nan 0.0500 0.0023
5 0.0331 nan 0.0500 -0.0001
6 0.0314 nan 0.0500 0.0009
7 0.0294 nan 0.0500 0.0020
8 0.0275 nan 0.0500 0.0017
9 0.0258 nan 0.0500 0.0013
10 0.0244 nan 0.0500 0.0015
20 0.0158 nan 0.0500 0.0007
40 0.0082 nan 0.0500 0.0002
60 0.0052 nan 0.0500 0.0001
80 0.0035 nan 0.0500 -0.0000
100 0.0025 nan 0.0500 -0.0000
120 0.0017 nan 0.0500 0.0000
140 0.0012 nan 0.0500 -0.0000
160 0.0009 nan 0.0500 -0.0000
180 0.0007 nan 0.0500 -0.0000
200 0.0005 nan 0.0500 -0.0000
- Fold27: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold27: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0417 nan 0.0500 0.0023
2 0.0384 nan 0.0500 0.0024
3 0.0356 nan 0.0500 0.0016
4 0.0327 nan 0.0500 0.0023
5 0.0301 nan 0.0500 0.0018
6 0.0282 nan 0.0500 0.0017
7 0.0260 nan 0.0500 0.0010
8 0.0242 nan 0.0500 0.0015
9 0.0233 nan 0.0500 0.0002
10 0.0224 nan 0.0500 0.0007
20 0.0120 nan 0.0500 0.0009
40 0.0039 nan 0.0500 -0.0000
60 0.0017 nan 0.0500 -0.0000
80 0.0008 nan 0.0500 -0.0000
100 0.0004 nan 0.0500 -0.0000
120 0.0002 nan 0.0500 0.0000
140 0.0001 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold27: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold27: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0416 nan 0.0500 0.0004
2 0.0401 nan 0.0500 -0.0005
3 0.0386 nan 0.0500 0.0001
4 0.0348 nan 0.0500 0.0033
5 0.0328 nan 0.0500 0.0013
6 0.0304 nan 0.0500 0.0019
7 0.0284 nan 0.0500 0.0020
8 0.0274 nan 0.0500 0.0006
9 0.0255 nan 0.0500 0.0018
10 0.0237 nan 0.0500 0.0016
20 0.0120 nan 0.0500 0.0000
40 0.0037 nan 0.0500 0.0000
60 0.0017 nan 0.0500 0.0001
80 0.0009 nan 0.0500 -0.0000
100 0.0005 nan 0.0500 -0.0000
120 0.0003 nan 0.0500 -0.0000
140 0.0002 nan 0.0500 0.0000
160 0.0001 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 0.0000
200 0.0001 nan 0.0500 0.0000
- Fold27: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold27: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0421 nan 0.0500 0.0014
2 0.0393 nan 0.0500 0.0026
3 0.0375 nan 0.0500 0.0023
4 0.0360 nan 0.0500 0.0014
5 0.0339 nan 0.0500 0.0006
6 0.0322 nan 0.0500 0.0018
7 0.0304 nan 0.0500 0.0008
8 0.0285 nan 0.0500 0.0012
9 0.0268 nan 0.0500 0.0012
10 0.0252 nan 0.0500 0.0013
20 0.0163 nan 0.0500 0.0001
40 0.0081 nan 0.0500 -0.0000
60 0.0050 nan 0.0500 0.0001
80 0.0032 nan 0.0500 0.0001
100 0.0024 nan 0.0500 0.0000
120 0.0018 nan 0.0500 -0.0000
140 0.0013 nan 0.0500 0.0000
160 0.0009 nan 0.0500 -0.0000
180 0.0006 nan 0.0500 -0.0000
200 0.0004 nan 0.0500 0.0000
- Fold27: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold27: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0407 nan 0.0500 0.0022
2 0.0395 nan 0.0500 0.0007
3 0.0359 nan 0.0500 0.0024
4 0.0331 nan 0.0500 0.0013
5 0.0317 nan 0.0500 0.0014
6 0.0298 nan 0.0500 0.0012
7 0.0281 nan 0.0500 0.0004
8 0.0262 nan 0.0500 0.0004
9 0.0237 nan 0.0500 0.0015
10 0.0220 nan 0.0500 0.0008
20 0.0119 nan 0.0500 0.0008
40 0.0037 nan 0.0500 0.0000
60 0.0014 nan 0.0500 0.0000
80 0.0006 nan 0.0500 -0.0000
100 0.0002 nan 0.0500 -0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0000 nan 0.0500 0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 0.0000
- Fold27: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold27: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0407 nan 0.0500 0.0038
2 0.0376 nan 0.0500 0.0024
3 0.0352 nan 0.0500 0.0014
4 0.0327 nan 0.0500 0.0019
5 0.0312 nan 0.0500 0.0010
6 0.0287 nan 0.0500 0.0016
7 0.0264 nan 0.0500 0.0019
8 0.0252 nan 0.0500 0.0008
9 0.0238 nan 0.0500 0.0017
10 0.0225 nan 0.0500 0.0010
20 0.0133 nan 0.0500 0.0007
40 0.0053 nan 0.0500 0.0001
60 0.0023 nan 0.0500 0.0001
80 0.0009 nan 0.0500 -0.0001
100 0.0005 nan 0.0500 0.0000
120 0.0003 nan 0.0500 -0.0000
140 0.0002 nan 0.0500 -0.0000
160 0.0001 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 0.0000
- Fold27: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold27: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0414 nan 0.0500 0.0030
2 0.0385 nan 0.0500 0.0016
3 0.0356 nan 0.0500 0.0014
4 0.0338 nan 0.0500 0.0015
5 0.0318 nan 0.0500 0.0022
6 0.0296 nan 0.0500 0.0020
7 0.0288 nan 0.0500 -0.0006
8 0.0268 nan 0.0500 0.0017
9 0.0255 nan 0.0500 0.0011
10 0.0240 nan 0.0500 0.0012
20 0.0149 nan 0.0500 0.0004
40 0.0074 nan 0.0500 0.0003
60 0.0041 nan 0.0500 -0.0001
80 0.0025 nan 0.0500 0.0000
100 0.0017 nan 0.0500 -0.0000
120 0.0011 nan 0.0500 0.0000
140 0.0007 nan 0.0500 0.0000
160 0.0005 nan 0.0500 -0.0000
180 0.0004 nan 0.0500 -0.0000
200 0.0003 nan 0.0500 0.0000
- Fold27: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold27: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0371 nan 0.1000 0.0052
2 0.0319 nan 0.1000 0.0049
3 0.0266 nan 0.1000 0.0014
4 0.0252 nan 0.1000 0.0011
5 0.0230 nan 0.1000 0.0010
6 0.0203 nan 0.1000 0.0025
7 0.0181 nan 0.1000 0.0023
8 0.0166 nan 0.1000 0.0018
9 0.0153 nan 0.1000 0.0007
10 0.0137 nan 0.1000 0.0016
20 0.0070 nan 0.1000 -0.0000
40 0.0018 nan 0.1000 0.0000
60 0.0006 nan 0.1000 0.0000
80 0.0002 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold27: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold27: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0382 nan 0.1000 0.0056
2 0.0344 nan 0.1000 0.0015
3 0.0295 nan 0.1000 0.0030
4 0.0270 nan 0.1000 0.0025
5 0.0234 nan 0.1000 0.0035
6 0.0212 nan 0.1000 0.0004
7 0.0197 nan 0.1000 0.0009
8 0.0176 nan 0.1000 0.0006
9 0.0170 nan 0.1000 -0.0003
10 0.0151 nan 0.1000 0.0003
20 0.0063 nan 0.1000 0.0003
40 0.0020 nan 0.1000 -0.0002
60 0.0009 nan 0.1000 0.0000
80 0.0005 nan 0.1000 -0.0000
100 0.0003 nan 0.1000 0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold27: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold27: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0427 nan 0.1000 -0.0017
2 0.0367 nan 0.1000 0.0052
3 0.0319 nan 0.1000 0.0042
4 0.0298 nan 0.1000 0.0021
5 0.0271 nan 0.1000 0.0031
6 0.0259 nan 0.1000 0.0007
7 0.0230 nan 0.1000 0.0028
8 0.0208 nan 0.1000 0.0019
9 0.0201 nan 0.1000 0.0007
10 0.0185 nan 0.1000 0.0018
20 0.0090 nan 0.1000 -0.0004
40 0.0027 nan 0.1000 -0.0001
60 0.0015 nan 0.1000 0.0001
80 0.0007 nan 0.1000 -0.0000
100 0.0004 nan 0.1000 -0.0000
120 0.0003 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0002 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold27: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold27: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0386 nan 0.1000 0.0029
2 0.0314 nan 0.1000 0.0036
3 0.0288 nan 0.1000 0.0003
4 0.0261 nan 0.1000 0.0020
5 0.0223 nan 0.1000 0.0024
6 0.0203 nan 0.1000 0.0009
7 0.0182 nan 0.1000 0.0014
8 0.0165 nan 0.1000 0.0005
9 0.0140 nan 0.1000 0.0015
10 0.0133 nan 0.1000 -0.0011
20 0.0043 nan 0.1000 -0.0003
40 0.0008 nan 0.1000 -0.0001
60 0.0002 nan 0.1000 0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 0.0000
- Fold27: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold27: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0375 nan 0.1000 0.0042
2 0.0318 nan 0.1000 0.0057
3 0.0276 nan 0.1000 0.0037
4 0.0233 nan 0.1000 0.0032
5 0.0215 nan 0.1000 0.0006
6 0.0181 nan 0.1000 0.0021
7 0.0164 nan 0.1000 0.0011
8 0.0138 nan 0.1000 0.0019
9 0.0120 nan 0.1000 0.0015
10 0.0104 nan 0.1000 0.0016
20 0.0034 nan 0.1000 0.0001
40 0.0009 nan 0.1000 0.0000
60 0.0002 nan 0.1000 0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold27: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold27: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0385 nan 0.1000 0.0036
2 0.0340 nan 0.1000 0.0045
3 0.0302 nan 0.1000 0.0023
4 0.0264 nan 0.1000 0.0030
5 0.0227 nan 0.1000 0.0034
6 0.0200 nan 0.1000 0.0027
7 0.0176 nan 0.1000 0.0018
8 0.0157 nan 0.1000 -0.0003
9 0.0140 nan 0.1000 0.0006
10 0.0130 nan 0.1000 0.0000
20 0.0073 nan 0.1000 -0.0004
40 0.0032 nan 0.1000 -0.0001
60 0.0013 nan 0.1000 -0.0001
80 0.0007 nan 0.1000 -0.0000
100 0.0004 nan 0.1000 0.0000
120 0.0002 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold27: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold27: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0363 nan 0.1000 0.0093
2 0.0304 nan 0.1000 0.0049
3 0.0268 nan 0.1000 0.0031
4 0.0229 nan 0.1000 0.0025
5 0.0195 nan 0.1000 0.0012
6 0.0186 nan 0.1000 0.0001
7 0.0151 nan 0.1000 0.0019
8 0.0128 nan 0.1000 0.0018
9 0.0109 nan 0.1000 0.0009
10 0.0089 nan 0.1000 0.0026
20 0.0027 nan 0.1000 -0.0000
40 0.0004 nan 0.1000 -0.0000
60 0.0001 nan 0.1000 -0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold27: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold27: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0376 nan 0.1000 0.0057
2 0.0330 nan 0.1000 0.0041
3 0.0294 nan 0.1000 0.0018
4 0.0260 nan 0.1000 0.0011
5 0.0228 nan 0.1000 0.0001
6 0.0197 nan 0.1000 0.0028
7 0.0164 nan 0.1000 0.0011
8 0.0149 nan 0.1000 0.0018
9 0.0136 nan 0.1000 0.0012
10 0.0127 nan 0.1000 0.0003
20 0.0039 nan 0.1000 0.0004
40 0.0007 nan 0.1000 0.0001
60 0.0002 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold27: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold27: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0376 nan 0.1000 0.0050
2 0.0328 nan 0.1000 0.0047
3 0.0294 nan 0.1000 0.0004
4 0.0267 nan 0.1000 0.0006
5 0.0233 nan 0.1000 0.0029
6 0.0205 nan 0.1000 0.0026
7 0.0205 nan 0.1000 -0.0014
8 0.0185 nan 0.1000 0.0020
9 0.0164 nan 0.1000 0.0017
10 0.0144 nan 0.1000 0.0004
20 0.0078 nan 0.1000 -0.0006
40 0.0026 nan 0.1000 0.0000
60 0.0010 nan 0.1000 -0.0000
80 0.0006 nan 0.1000 -0.0000
100 0.0003 nan 0.1000 -0.0000
120 0.0002 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 0.0000
160 0.0001 nan 0.1000 0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold27: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold28: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0406 nan 0.0100 0.0003
2 0.0401 nan 0.0100 0.0006
3 0.0399 nan 0.0100 -0.0001
4 0.0396 nan 0.0100 0.0004
5 0.0390 nan 0.0100 0.0005
6 0.0386 nan 0.0100 0.0002
7 0.0381 nan 0.0100 0.0004
8 0.0375 nan 0.0100 0.0005
9 0.0369 nan 0.0100 0.0004
10 0.0364 nan 0.0100 0.0004
20 0.0321 nan 0.0100 0.0004
40 0.0260 nan 0.0100 0.0003
60 0.0204 nan 0.0100 0.0001
80 0.0171 nan 0.0100 0.0001
100 0.0143 nan 0.0100 0.0001
120 0.0119 nan 0.0100 0.0001
140 0.0099 nan 0.0100 0.0000
160 0.0082 nan 0.0100 0.0000
180 0.0069 nan 0.0100 -0.0000
200 0.0060 nan 0.0100 -0.0000
- Fold28: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold28: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0407 nan 0.0100 0.0003
2 0.0402 nan 0.0100 0.0001
3 0.0396 nan 0.0100 0.0006
4 0.0391 nan 0.0100 0.0004
5 0.0385 nan 0.0100 0.0005
6 0.0379 nan 0.0100 0.0004
7 0.0373 nan 0.0100 0.0006
8 0.0370 nan 0.0100 0.0002
9 0.0368 nan 0.0100 -0.0001
10 0.0364 nan 0.0100 0.0004
20 0.0323 nan 0.0100 0.0003
40 0.0258 nan 0.0100 -0.0000
60 0.0213 nan 0.0100 0.0002
80 0.0176 nan 0.0100 0.0001
100 0.0147 nan 0.0100 0.0000
120 0.0128 nan 0.0100 0.0001
140 0.0108 nan 0.0100 0.0000
160 0.0091 nan 0.0100 0.0000
180 0.0077 nan 0.0100 0.0000
200 0.0066 nan 0.0100 0.0000
- Fold28: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold28: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0404 nan 0.0100 0.0006
2 0.0397 nan 0.0100 0.0006
3 0.0392 nan 0.0100 0.0005
4 0.0391 nan 0.0100 -0.0002
5 0.0385 nan 0.0100 0.0004
6 0.0379 nan 0.0100 0.0002
7 0.0375 nan 0.0100 0.0004
8 0.0371 nan 0.0100 0.0002
9 0.0367 nan 0.0100 0.0004
10 0.0361 nan 0.0100 0.0005
20 0.0321 nan 0.0100 0.0004
40 0.0262 nan 0.0100 0.0000
60 0.0219 nan 0.0100 0.0001
80 0.0182 nan 0.0100 0.0001
100 0.0159 nan 0.0100 0.0001
120 0.0135 nan 0.0100 0.0000
140 0.0117 nan 0.0100 -0.0000
160 0.0107 nan 0.0100 -0.0001
180 0.0097 nan 0.0100 0.0000
200 0.0087 nan 0.0100 -0.0000
- Fold28: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold28: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0405 nan 0.0100 0.0004
2 0.0397 nan 0.0100 0.0010
3 0.0390 nan 0.0100 0.0006
4 0.0386 nan 0.0100 0.0002
5 0.0381 nan 0.0100 0.0004
6 0.0374 nan 0.0100 0.0009
7 0.0369 nan 0.0100 0.0004
8 0.0363 nan 0.0100 0.0005
9 0.0359 nan 0.0100 0.0002
10 0.0354 nan 0.0100 0.0005
20 0.0310 nan 0.0100 0.0002
40 0.0233 nan 0.0100 0.0003
60 0.0181 nan 0.0100 0.0001
80 0.0140 nan 0.0100 0.0001
100 0.0110 nan 0.0100 0.0001
120 0.0089 nan 0.0100 0.0000
140 0.0070 nan 0.0100 0.0000
160 0.0056 nan 0.0100 0.0000
180 0.0045 nan 0.0100 0.0000
200 0.0037 nan 0.0100 0.0000
- Fold28: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold28: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0407 nan 0.0100 0.0002
2 0.0399 nan 0.0100 0.0004
3 0.0394 nan 0.0100 0.0005
4 0.0388 nan 0.0100 0.0004
5 0.0383 nan 0.0100 0.0005
6 0.0377 nan 0.0100 0.0005
7 0.0371 nan 0.0100 0.0004
8 0.0368 nan 0.0100 0.0003
9 0.0362 nan 0.0100 0.0004
10 0.0358 nan 0.0100 0.0004
20 0.0319 nan 0.0100 0.0001
40 0.0253 nan 0.0100 0.0002
60 0.0202 nan 0.0100 0.0002
80 0.0161 nan 0.0100 0.0002
100 0.0128 nan 0.0100 0.0001
120 0.0103 nan 0.0100 -0.0000
140 0.0086 nan 0.0100 0.0001
160 0.0070 nan 0.0100 0.0000
180 0.0058 nan 0.0100 0.0000
200 0.0049 nan 0.0100 0.0000
- Fold28: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold28: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0408 nan 0.0100 0.0000
2 0.0403 nan 0.0100 0.0002
3 0.0397 nan 0.0100 0.0003
4 0.0394 nan 0.0100 -0.0001
5 0.0389 nan 0.0100 0.0005
6 0.0385 nan 0.0100 0.0001
7 0.0381 nan 0.0100 0.0004
8 0.0376 nan 0.0100 0.0003
9 0.0372 nan 0.0100 0.0002
10 0.0367 nan 0.0100 0.0004
20 0.0332 nan 0.0100 0.0004
40 0.0270 nan 0.0100 0.0003
60 0.0222 nan 0.0100 0.0001
80 0.0184 nan 0.0100 0.0000
100 0.0153 nan 0.0100 0.0000
120 0.0135 nan 0.0100 -0.0000
140 0.0119 nan 0.0100 0.0000
160 0.0107 nan 0.0100 -0.0000
180 0.0096 nan 0.0100 0.0001
200 0.0084 nan 0.0100 -0.0000
- Fold28: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold28: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0407 nan 0.0100 0.0002
2 0.0399 nan 0.0100 0.0007
3 0.0393 nan 0.0100 0.0005
4 0.0387 nan 0.0100 0.0005
5 0.0381 nan 0.0100 0.0004
6 0.0377 nan 0.0100 0.0005
7 0.0374 nan 0.0100 0.0003
8 0.0369 nan 0.0100 0.0004
9 0.0364 nan 0.0100 0.0002
10 0.0359 nan 0.0100 0.0004
20 0.0312 nan 0.0100 0.0000
40 0.0234 nan 0.0100 0.0003
60 0.0178 nan 0.0100 0.0002
80 0.0142 nan 0.0100 0.0001
100 0.0110 nan 0.0100 0.0001
120 0.0084 nan 0.0100 0.0001
140 0.0068 nan 0.0100 0.0001
160 0.0053 nan 0.0100 0.0000
180 0.0044 nan 0.0100 0.0000
200 0.0035 nan 0.0100 -0.0001
- Fold28: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold28: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0406 nan 0.0100 0.0005
2 0.0398 nan 0.0100 0.0003
3 0.0396 nan 0.0100 0.0001
4 0.0390 nan 0.0100 0.0005
5 0.0387 nan 0.0100 0.0002
6 0.0382 nan 0.0100 -0.0000
7 0.0375 nan 0.0100 0.0006
8 0.0371 nan 0.0100 0.0003
9 0.0364 nan 0.0100 0.0004
10 0.0361 nan 0.0100 0.0001
20 0.0316 nan 0.0100 0.0002
40 0.0248 nan 0.0100 0.0001
60 0.0199 nan 0.0100 0.0000
80 0.0153 nan 0.0100 0.0001
100 0.0123 nan 0.0100 0.0001
120 0.0101 nan 0.0100 0.0001
140 0.0084 nan 0.0100 0.0000
160 0.0068 nan 0.0100 -0.0000
180 0.0055 nan 0.0100 0.0000
200 0.0047 nan 0.0100 -0.0000
- Fold28: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold28: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0405 nan 0.0100 0.0004
2 0.0400 nan 0.0100 0.0004
3 0.0395 nan 0.0100 0.0005
4 0.0390 nan 0.0100 0.0003
5 0.0384 nan 0.0100 0.0006
6 0.0378 nan 0.0100 0.0000
7 0.0375 nan 0.0100 0.0004
8 0.0371 nan 0.0100 0.0000
9 0.0368 nan 0.0100 0.0002
10 0.0364 nan 0.0100 0.0003
20 0.0322 nan 0.0100 0.0004
40 0.0264 nan 0.0100 0.0001
60 0.0219 nan 0.0100 0.0001
80 0.0184 nan 0.0100 0.0002
100 0.0155 nan 0.0100 0.0001
120 0.0133 nan 0.0100 0.0001
140 0.0117 nan 0.0100 0.0000
160 0.0103 nan 0.0100 0.0000
180 0.0091 nan 0.0100 0.0000
200 0.0083 nan 0.0100 0.0000
- Fold28: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold28: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0390 nan 0.0500 0.0015
2 0.0369 nan 0.0500 0.0018
3 0.0344 nan 0.0500 0.0024
4 0.0319 nan 0.0500 0.0019
5 0.0308 nan 0.0500 0.0006
6 0.0288 nan 0.0500 0.0015
7 0.0276 nan 0.0500 0.0004
8 0.0260 nan 0.0500 0.0008
9 0.0245 nan 0.0500 0.0013
10 0.0230 nan 0.0500 0.0015
20 0.0143 nan 0.0500 0.0005
40 0.0063 nan 0.0500 0.0000
60 0.0031 nan 0.0500 -0.0000
80 0.0015 nan 0.0500 -0.0001
100 0.0009 nan 0.0500 -0.0000
120 0.0005 nan 0.0500 0.0000
140 0.0003 nan 0.0500 0.0000
160 0.0002 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 0.0000
200 0.0001 nan 0.0500 -0.0000
- Fold28: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold28: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0390 nan 0.0500 0.0025
2 0.0363 nan 0.0500 0.0025
3 0.0339 nan 0.0500 0.0024
4 0.0321 nan 0.0500 0.0020
5 0.0309 nan 0.0500 0.0009
6 0.0297 nan 0.0500 0.0013
7 0.0282 nan 0.0500 0.0013
8 0.0273 nan 0.0500 0.0004
9 0.0261 nan 0.0500 0.0013
10 0.0244 nan 0.0500 0.0010
20 0.0156 nan 0.0500 0.0001
40 0.0072 nan 0.0500 0.0003
60 0.0035 nan 0.0500 0.0000
80 0.0020 nan 0.0500 0.0000
100 0.0012 nan 0.0500 0.0000
120 0.0008 nan 0.0500 -0.0000
140 0.0005 nan 0.0500 -0.0000
160 0.0003 nan 0.0500 -0.0000
180 0.0002 nan 0.0500 0.0000
200 0.0001 nan 0.0500 0.0000
- Fold28: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold28: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0380 nan 0.0500 0.0027
2 0.0361 nan 0.0500 0.0020
3 0.0342 nan 0.0500 0.0013
4 0.0327 nan 0.0500 0.0014
5 0.0311 nan 0.0500 0.0018
6 0.0303 nan 0.0500 0.0001
7 0.0287 nan 0.0500 0.0010
8 0.0274 nan 0.0500 0.0016
9 0.0255 nan 0.0500 0.0011
10 0.0242 nan 0.0500 0.0002
20 0.0157 nan 0.0500 0.0003
40 0.0081 nan 0.0500 0.0003
60 0.0053 nan 0.0500 -0.0001
80 0.0039 nan 0.0500 -0.0001
100 0.0027 nan 0.0500 0.0000
120 0.0018 nan 0.0500 -0.0000
140 0.0014 nan 0.0500 0.0000
160 0.0011 nan 0.0500 -0.0000
180 0.0008 nan 0.0500 0.0000
200 0.0007 nan 0.0500 -0.0000
- Fold28: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold28: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0373 nan 0.0500 0.0015
2 0.0366 nan 0.0500 -0.0007
3 0.0348 nan 0.0500 0.0013
4 0.0322 nan 0.0500 0.0021
5 0.0297 nan 0.0500 0.0018
6 0.0279 nan 0.0500 0.0003
7 0.0266 nan 0.0500 0.0012
8 0.0250 nan 0.0500 -0.0004
9 0.0230 nan 0.0500 0.0003
10 0.0223 nan 0.0500 -0.0008
20 0.0128 nan 0.0500 0.0004
40 0.0041 nan 0.0500 0.0000
60 0.0015 nan 0.0500 0.0000
80 0.0007 nan 0.0500 0.0000
100 0.0004 nan 0.0500 -0.0000
120 0.0002 nan 0.0500 -0.0000
140 0.0001 nan 0.0500 0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 -0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold28: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold28: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0375 nan 0.0500 0.0027
2 0.0351 nan 0.0500 0.0020
3 0.0328 nan 0.0500 0.0019
4 0.0304 nan 0.0500 0.0016
5 0.0281 nan 0.0500 0.0009
6 0.0261 nan 0.0500 0.0014
7 0.0246 nan 0.0500 0.0011
8 0.0226 nan 0.0500 0.0006
9 0.0220 nan 0.0500 0.0004
10 0.0205 nan 0.0500 0.0010
20 0.0116 nan 0.0500 0.0002
40 0.0049 nan 0.0500 0.0001
60 0.0023 nan 0.0500 0.0000
80 0.0011 nan 0.0500 -0.0000
100 0.0006 nan 0.0500 0.0000
120 0.0004 nan 0.0500 0.0000
140 0.0002 nan 0.0500 -0.0000
160 0.0001 nan 0.0500 -0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 0.0000
- Fold28: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold28: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0386 nan 0.0500 0.0017
2 0.0373 nan 0.0500 0.0008
3 0.0349 nan 0.0500 0.0006
4 0.0331 nan 0.0500 0.0015
5 0.0312 nan 0.0500 0.0008
6 0.0295 nan 0.0500 0.0017
7 0.0281 nan 0.0500 0.0010
8 0.0267 nan 0.0500 0.0013
9 0.0251 nan 0.0500 0.0014
10 0.0244 nan 0.0500 0.0001
20 0.0167 nan 0.0500 0.0003
40 0.0092 nan 0.0500 -0.0001
60 0.0061 nan 0.0500 0.0000
80 0.0042 nan 0.0500 -0.0000
100 0.0027 nan 0.0500 0.0000
120 0.0020 nan 0.0500 -0.0000
140 0.0012 nan 0.0500 0.0000
160 0.0009 nan 0.0500 0.0000
180 0.0007 nan 0.0500 -0.0000
200 0.0005 nan 0.0500 -0.0000
- Fold28: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold28: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0371 nan 0.0500 0.0049
2 0.0350 nan 0.0500 0.0009
3 0.0320 nan 0.0500 0.0024
4 0.0301 nan 0.0500 0.0014
5 0.0279 nan 0.0500 0.0003
6 0.0269 nan 0.0500 0.0000
7 0.0252 nan 0.0500 0.0012
8 0.0234 nan 0.0500 0.0017
9 0.0215 nan 0.0500 0.0010
10 0.0202 nan 0.0500 0.0014
20 0.0102 nan 0.0500 0.0002
40 0.0032 nan 0.0500 0.0000
60 0.0013 nan 0.0500 -0.0000
80 0.0006 nan 0.0500 0.0000
100 0.0002 nan 0.0500 -0.0000
120 0.0001 nan 0.0500 -0.0000
140 0.0000 nan 0.0500 -0.0000
160 0.0000 nan 0.0500 -0.0000
180 0.0000 nan 0.0500 0.0000
200 0.0000 nan 0.0500 -0.0000
- Fold28: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold28: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0384 nan 0.0500 0.0022
2 0.0353 nan 0.0500 0.0026
3 0.0320 nan 0.0500 0.0029
4 0.0295 nan 0.0500 0.0020
5 0.0273 nan 0.0500 0.0021
6 0.0259 nan 0.0500 0.0011
7 0.0242 nan 0.0500 0.0012
8 0.0226 nan 0.0500 0.0015
9 0.0209 nan 0.0500 0.0018
10 0.0194 nan 0.0500 0.0009
20 0.0112 nan 0.0500 0.0003
40 0.0041 nan 0.0500 -0.0000
60 0.0017 nan 0.0500 0.0000
80 0.0009 nan 0.0500 -0.0000
100 0.0005 nan 0.0500 0.0000
120 0.0003 nan 0.0500 -0.0000
140 0.0002 nan 0.0500 -0.0000
160 0.0001 nan 0.0500 0.0000
180 0.0001 nan 0.0500 -0.0000
200 0.0001 nan 0.0500 0.0000
- Fold28: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold28: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0385 nan 0.0500 0.0020
2 0.0374 nan 0.0500 0.0007
3 0.0362 nan 0.0500 -0.0002
4 0.0346 nan 0.0500 0.0015
5 0.0334 nan 0.0500 -0.0003
6 0.0311 nan 0.0500 0.0018
7 0.0306 nan 0.0500 0.0001
8 0.0290 nan 0.0500 0.0011
9 0.0269 nan 0.0500 0.0008
10 0.0263 nan 0.0500 0.0005
20 0.0174 nan 0.0500 0.0008
40 0.0092 nan 0.0500 0.0002
60 0.0058 nan 0.0500 -0.0001
80 0.0040 nan 0.0500 -0.0001
100 0.0030 nan 0.0500 -0.0000
120 0.0021 nan 0.0500 0.0000
140 0.0015 nan 0.0500 -0.0000
160 0.0011 nan 0.0500 -0.0000
180 0.0008 nan 0.0500 0.0000
200 0.0007 nan 0.0500 -0.0000
- Fold28: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200
+ Fold28: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0353 nan 0.1000 0.0051
2 0.0318 nan 0.1000 0.0043
3 0.0284 nan 0.1000 0.0027
4 0.0259 nan 0.1000 0.0028
5 0.0234 nan 0.1000 0.0027
6 0.0204 nan 0.1000 0.0021
7 0.0199 nan 0.1000 -0.0010
8 0.0177 nan 0.1000 0.0021
9 0.0160 nan 0.1000 0.0001
10 0.0141 nan 0.1000 0.0023
20 0.0076 nan 0.1000 0.0008
40 0.0023 nan 0.1000 -0.0001
60 0.0008 nan 0.1000 -0.0001
80 0.0003 nan 0.1000 -0.0000
100 0.0001 nan 0.1000 0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold28: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200
+ Fold28: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0349 nan 0.1000 0.0051
2 0.0309 nan 0.1000 0.0042
3 0.0291 nan 0.1000 0.0018
4 0.0263 nan 0.1000 0.0020
5 0.0230 nan 0.1000 0.0025
6 0.0199 nan 0.1000 0.0030
7 0.0182 nan 0.1000 0.0003
8 0.0158 nan 0.1000 0.0011
9 0.0141 nan 0.1000 0.0013
10 0.0138 nan 0.1000 0.0001
20 0.0062 nan 0.1000 0.0000
40 0.0023 nan 0.1000 -0.0000
60 0.0008 nan 0.1000 -0.0000
80 0.0004 nan 0.1000 0.0000
100 0.0002 nan 0.1000 -0.0000
120 0.0001 nan 0.1000 0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold28: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200
+ Fold28: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0347 nan 0.1000 0.0051
2 0.0314 nan 0.1000 0.0013
3 0.0283 nan 0.1000 0.0027
4 0.0260 nan 0.1000 0.0000
5 0.0235 nan 0.1000 0.0018
6 0.0210 nan 0.1000 0.0019
7 0.0184 nan 0.1000 0.0019
8 0.0172 nan 0.1000 0.0011
9 0.0155 nan 0.1000 0.0013
10 0.0142 nan 0.1000 0.0012
20 0.0084 nan 0.1000 0.0001
40 0.0037 nan 0.1000 0.0001
60 0.0023 nan 0.1000 0.0000
80 0.0013 nan 0.1000 -0.0001
100 0.0008 nan 0.1000 -0.0000
120 0.0005 nan 0.1000 0.0000
140 0.0003 nan 0.1000 -0.0000
160 0.0003 nan 0.1000 -0.0000
180 0.0002 nan 0.1000 0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold28: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200
+ Fold28: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0392 nan 0.1000 -0.0004
2 0.0358 nan 0.1000 0.0029
3 0.0298 nan 0.1000 0.0026
4 0.0253 nan 0.1000 0.0046
5 0.0201 nan 0.1000 0.0046
6 0.0172 nan 0.1000 0.0023
7 0.0161 nan 0.1000 0.0004
8 0.0159 nan 0.1000 -0.0006
9 0.0153 nan 0.1000 0.0001
10 0.0140 nan 0.1000 0.0002
20 0.0047 nan 0.1000 0.0005
40 0.0007 nan 0.1000 0.0000
60 0.0002 nan 0.1000 -0.0000
80 0.0001 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold28: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200
+ Fold28: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0371 nan 0.1000 0.0021
2 0.0338 nan 0.1000 0.0035
3 0.0298 nan 0.1000 0.0041
4 0.0281 nan 0.1000 0.0001
5 0.0238 nan 0.1000 0.0007
6 0.0208 nan 0.1000 0.0021
7 0.0171 nan 0.1000 0.0013
8 0.0147 nan 0.1000 0.0013
9 0.0140 nan 0.1000 0.0003
10 0.0122 nan 0.1000 -0.0001
20 0.0051 nan 0.1000 -0.0000
40 0.0012 nan 0.1000 0.0000
60 0.0006 nan 0.1000 0.0000
80 0.0003 nan 0.1000 -0.0000
100 0.0002 nan 0.1000 -0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold28: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200
+ Fold28: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0375 nan 0.1000 0.0028
2 0.0322 nan 0.1000 0.0051
3 0.0293 nan 0.1000 0.0030
4 0.0262 nan 0.1000 0.0030
5 0.0238 nan 0.1000 0.0017
6 0.0215 nan 0.1000 0.0012
7 0.0188 nan 0.1000 0.0021
8 0.0167 nan 0.1000 0.0018
9 0.0152 nan 0.1000 0.0011
10 0.0138 nan 0.1000 0.0003
20 0.0064 nan 0.1000 0.0002
40 0.0026 nan 0.1000 -0.0001
60 0.0013 nan 0.1000 0.0000
80 0.0008 nan 0.1000 0.0000
100 0.0004 nan 0.1000 -0.0000
120 0.0002 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0001 nan 0.1000 -0.0000
- Fold28: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200
+ Fold28: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0340 nan 0.1000 0.0058
2 0.0291 nan 0.1000 0.0048
3 0.0267 nan 0.1000 0.0004
4 0.0215 nan 0.1000 0.0048
5 0.0194 nan 0.1000 0.0011
6 0.0173 nan 0.1000 0.0009
7 0.0146 nan 0.1000 0.0028
8 0.0120 nan 0.1000 0.0021
9 0.0109 nan 0.1000 -0.0000
10 0.0089 nan 0.1000 0.0019
20 0.0032 nan 0.1000 -0.0002
40 0.0005 nan 0.1000 -0.0001
60 0.0001 nan 0.1000 -0.0000
80 0.0000 nan 0.1000 -0.0000
100 0.0000 nan 0.1000 -0.0000
120 0.0000 nan 0.1000 -0.0000
140 0.0000 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold28: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200
+ Fold28: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0360 nan 0.1000 0.0057
2 0.0332 nan 0.1000 0.0004
3 0.0299 nan 0.1000 -0.0013
4 0.0271 nan 0.1000 0.0030
5 0.0237 nan 0.1000 0.0022
6 0.0198 nan 0.1000 0.0028
7 0.0165 nan 0.1000 0.0012
8 0.0148 nan 0.1000 0.0020
9 0.0137 nan 0.1000 0.0004
10 0.0123 nan 0.1000 0.0012
20 0.0062 nan 0.1000 -0.0004
40 0.0023 nan 0.1000 -0.0002
60 0.0011 nan 0.1000 0.0001
80 0.0006 nan 0.1000 -0.0000
100 0.0003 nan 0.1000 0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold28: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200
+ Fold28: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0362 nan 0.1000 0.0032
2 0.0318 nan 0.1000 0.0013
3 0.0272 nan 0.1000 0.0041
4 0.0246 nan 0.1000 0.0031
5 0.0231 nan 0.1000 0.0014
6 0.0204 nan 0.1000 0.0004
7 0.0183 nan 0.1000 0.0016
8 0.0178 nan 0.1000 0.0004
9 0.0160 nan 0.1000 0.0008
10 0.0149 nan 0.1000 0.0008
20 0.0077 nan 0.1000 0.0002
40 0.0026 nan 0.1000 -0.0000
60 0.0012 nan 0.1000 -0.0000
80 0.0007 nan 0.1000 0.0000
100 0.0003 nan 0.1000 0.0000
120 0.0003 nan 0.1000 -0.0000
140 0.0002 nan 0.1000 0.0000
160 0.0001 nan 0.1000 -0.0000
180 0.0001 nan 0.1000 -0.0000
200 0.0000 nan 0.1000 -0.0000
- Fold28: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200
Aggregating results
Selecting tuning parameters
Fitting n.trees = 200, interaction.depth = 1, shrinkage = 0.1, n.minobsinnode = 3 on full training set
Iter TrainDeviance ValidDeviance StepSize Improve
1 0.0378 nan 0.1000 0.0055
2 0.0330 nan 0.1000 0.0041
3 0.0290 nan 0.1000 0.0037
4 0.0267 nan 0.1000 0.0013
5 0.0239 nan 0.1000 0.0029
6 0.0214 nan 0.1000 0.0027
7 0.0196 nan 0.1000 0.0021
8 0.0170 nan 0.1000 0.0020
9 0.0155 nan 0.1000 0.0015
10 0.0151 nan 0.1000 -0.0014
20 0.0072 nan 0.1000 -0.0001
40 0.0020 nan 0.1000 0.0000
60 0.0011 nan 0.1000 0.0000
80 0.0005 nan 0.1000 0.0000
100 0.0002 nan 0.1000 -0.0000
120 0.0001 nan 0.1000 -0.0000
140 0.0001 nan 0.1000 -0.0000
160 0.0000 nan 0.1000 -0.0000
180 0.0000 nan 0.1000 0.0000
200 0.0000 nan 0.1000 -0.0000Comparing predictions
elastic_pred <- predict(elastic_net_model, data_aggr)
rf_pred <- predict(rf_model, data_aggr)
gbm_pred <- predict(gbm_model, data_aggr)
# Actual values
actual <- data_aggr$mean_trans_docs
# Create a data frame with all predictions and actual values
all_predictions <- data.frame(
country = data_aggr$country,
actual = actual,
elastic_net = elastic_pred,
random_forest = rf_pred,
gradient_boosting = gbm_pred
)
# Calculate errors for each model
all_predictions$elastic_error <- abs(all_predictions$actual - all_predictions$elastic_net)
all_predictions$rf_error <- abs(all_predictions$actual - all_predictions$random_forest)
all_predictions$gbm_error <- abs(all_predictions$actual - all_predictions$gradient_boosting)
# Calculate performance metrics for each model
calculate_metrics <- function(actual, predicted) {
residuals <- actual - predicted
r_squared <- 1 - sum(residuals^2) / sum((actual - mean(actual))^2)
rmse <- sqrt(mean(residuals^2))
mae <- mean(abs(residuals))
return(c(R_squared = r_squared, RMSE = rmse, MAE = mae))
}
# Get metrics for each model
elastic_metrics <- calculate_metrics(actual, elastic_pred)
rf_metrics <- calculate_metrics(actual, rf_pred)
gbm_metrics <- calculate_metrics(actual, gbm_pred)
# Combine metrics
model_metrics <- rbind(
Elastic_Net = elastic_metrics,
Random_Forest = rf_metrics,
Gradient_Boosting = gbm_metrics
)
# Print performance comparison
print(model_metrics) R_squared RMSE MAE
Elastic_Net 0.9469052 0.047712555 0.040121652
Random_Forest 0.9624421 0.040128869 0.033077032
Gradient_Boosting 0.9998393 0.002624701 0.001677268# Sort predictions by actual values (descending)
sorted_predictions <- all_predictions[order(all_predictions$actual, decreasing = TRUE), ]
# Print sorted predictions
print(sorted_predictions[, c("country", "actual", "elastic_net", "random_forest", "gradient_boosting")]) country actual elastic_net random_forest gradient_boosting
9 ES 0.9033659 0.8524193 0.8229980 0.8943799
22 NL 0.8663265 0.8423528 0.8282076 0.8654335
21 MT 0.8526786 0.8221836 0.8044864 0.8553885
7 DK 0.7967742 0.7403161 0.7668226 0.7955572
6 DE 0.7906977 0.7787671 0.7752393 0.7907475
11 FR 0.7901639 0.7352544 0.7787188 0.7894155
19 LU 0.7884615 0.7664504 0.7721643 0.7896432
24 PT 0.7749726 0.6632592 0.7435922 0.7750610
16 IE 0.7324263 0.7264290 0.7310612 0.7321643
2 BE 0.7278107 0.7260266 0.6970312 0.7274396
26 SE 0.7217295 0.7265787 0.7351573 0.7225695
10 FI 0.7100793 0.7267072 0.7283696 0.7098319
12 GB 0.7014428 0.7396484 0.7283549 0.7049659
1 AT 0.6154650 0.6371225 0.6489905 0.6163184
8 EE 0.6127024 0.5584945 0.5657370 0.6109038
13 GR 0.5980498 0.6064764 0.5695054 0.5978351
4 CY 0.5388471 0.5638382 0.5222309 0.5388480
27 SI 0.5282609 0.5777653 0.5664119 0.5288987
23 PL 0.5000000 0.4459348 0.4484063 0.4956427
20 LV 0.4840614 0.4266426 0.4447476 0.4815411
17 IT 0.4769404 0.5510112 0.5087186 0.4748203
14 HR 0.4539474 0.5159239 0.4814678 0.4538986
5 CZ 0.4472252 0.4214334 0.4667415 0.4484678
18 LT 0.4265570 0.4801427 0.4400768 0.4282762
28 SK 0.2990971 0.3362504 0.2958200 0.2984954
25 RO 0.2386740 0.2716489 0.2695934 0.2385616
3 BG 0.1666667 0.2572985 0.2623803 0.1724222
15 HU 0.1594684 0.2065162 0.2466841 0.1633312# Visualize predictions across countries
# Reshape the data for plotting
plot_data <- sorted_predictions %>%
select(country, actual, elastic_net, random_forest, gradient_boosting) %>%
gather(key = "model", value = "prediction", -country, -actual)
# Create plot
ggplot(plot_data, aes(x = reorder(country, -actual), y = prediction, fill = model)) +
geom_bar(stat = "identity", position = position_dodge()) +
geom_point(aes(y = actual), color = "black", size = 2) +
theme_minimal() +
theme(axis.text.x = element_text(angle = 90, hjust = 1)) +
labs(title = "Model Predictions vs Actual Values by Country",
x = "Country", y = "Proportion Supporting Trans Document Changes") +
scale_fill_brewer(palette = "Set1")
# Create a scatterplot of actual vs predicted for each model
ggplot(plot_data, aes(x = actual, y = prediction, color = model)) +
geom_point(size = 3, alpha = 0.7) +
geom_abline(intercept = 0, slope = 1, linetype = "dashed") +
facet_wrap(~model) +
theme_minimal() +
labs(title = "Actual vs Predicted Values by Model",
x = "Actual Values", y = "Predicted Values")
# Find which model performed best for each country
all_predictions$best_model <- apply(all_predictions[, c("elastic_error", "rf_error", "gbm_error")], 1,
function(x) c("Elastic Net", "Random Forest", "Gradient Boosting")[which.min(x)])
# Count how many countries each model performed best on
table(all_predictions$best_model)
Gradient Boosting
28 # Calculate residuals
gbm_residuals <- actual - gbm_pred
# Create a dataframe
residuals_df <- data.frame(actual, gbm_residuals)
# Plot residuals
ggplot(residuals_df, aes(x = actual, y = gbm_residuals)) +
geom_point(color = "red", alpha = 0.7) +
geom_hline(yintercept = 0, linetype = "dashed") +
theme_minimal() +
labs(title = "Residuals Plot for Gradient Boosting",
x = "Actual Values", y = "Residuals")
library(gbm)
gbm_importance <- varImp(gbm_model, scale = FALSE)
# Plot importance
ggplot(gbm_importance, aes(x = reorder(rownames(gbm_importance), Overall), y = Overall)) +
geom_col(fill = "blue") +
coord_flip() +
theme_minimal() +
labs(title = "Feature Importance - Gradient Boosting",
x = "Features", y = "Importance")
gbm_importancegbm variable importance
only 20 most important variables shown (out of 77)
Overall
democracy_index 0.71634
mean_antilgbtq_rights 0.63375
`friends_trans_Refusal (SPONTANEOUS)` 0.36218
mean_gender_docs 0.35293
`marital_status_Single (9-10 in d7)` 0.18382
mean_minority_discri 0.17790
mean_years_edu 0.14287
`occupation_Students (2 in d15a)` 0.14179
mean_roma_minority 0.11544
gdp_pc_ppp 0.10356
`phone_access_No telephone` 0.09767
`phone_access_Mobile only` 0.08173
`occupation_Managers (10 to 12 in d15a)` 0.07732
`occupation_Manual workers (15 to 18 in d15a)` 0.06055
`life_sat_Not very satisfied` 0.05583
`left_right_(7 -10) Right` 0.05401
`occupation_Unemployed (3 in d15a)` 0.05084
`occupation_House persons (1 in d15a)` 0.05031
`life_sat_Not at all satisfied` 0.04963
`left_right_(1 - 4) Left` 0.03986Brad’s theory notes
Leaving this section here, it is to be deleted as we incorporate what we need from here into the explanatory model part
Running a different logistic model for each country
We now have a table to test some glmer modelling on.
Following this tutorial Marga sent and applying to the test data:
https://raffaelevacca.github.io/Intro-multilevel-with-R/
Testing a nested dataset by country
# Commented the below as we are probably not gonna use it
#
# nested.cntry <- complete_df %>%
# group_by(country) %>%
# nest()
#
# # The column nested.df$data is a list of data frames, one for each country
# class(nested.cntry$data) # type, list
# length(nested.cntry$data) # number of countries
#
# # to unnest()
# nested.cntry %>%
# filter(country == "AT") %>%
# dplyr::select(country, data) %>%
# unnest(cols = c(data))
# # Using the nested data, we now run a model for each country:
# # fit separate lm for each each element of nested.cntry$data)
# lmodels <- nested.cntry %>%
# # Get all data frames
# pull(data) %>%
# # Run glm() on each via map because it's a classification model
# # model run against all vairables for now.
# purrr::map(~ glm(trans_docs ~ .,
# data= .x,
# family = "binomial"))
#
# # show that it's a list and we can call each elements regression output.
# class(lmodels)
# lmodels[4]Mixed models
Fixed effects: Things that are the same across the cluster Random effects: Things that change within the cluster
The fixed and random effects could refer to either the intercept or the slope, as these can both vary between groups.
LMM equation structure in R
To run a multilevel linear model, we use the lmer() function (“Linear Mixed Effects in R”) from the lme4 package. The syntax is similar to regression. everything to the left of the | indicates the effects that should be random, and the variable to the right of the | is the grouping variable across which the effects should vary
Null model This has no slope, but random intercepts. It basically just takes the average. It has no independent (X) variables and is the proper naïve model.
null_model <- lmer(Y ~ (1|cntry), data = ess)
Random intercept model: –> Only the intercept differ. The slopes are equal for each group. We assume the same effect of X on Y for each group. Just that the group causes the difference.
random_int_model <- lmer(Y ~ X + (1 | group), data=df)
Random intercept, random slope model –> Now we also let the slope vary by group. This means each group basically has it’s own model. It is
random_intslope_model <- lmer(Y ~ X + (X | group), data=df)
For each, Y=target, X = independent vars (can be many)
Standard LMM Modelling Strategy
(sourced from slides here: https://favstats.github.io/intro_multilevel/slides/#54) ^ This is a useful resource, it goes through an ESS modelling doc
Approach to multilevel model building based on Hox (2010)
1/ Null Model (Random Intercept only) 2/ Add independent Level 1 variables 3/ Add independent Level 2 variables 4/ Add random slopes 5/ (Cross-level) interactions
Each step, check whether your model is significantly improved compared to the previous one.
Basic LMM testing with toy data
First, null model:
# m_null <- glmer(trans_docs ~ (1|country),
# data = complete_df,
# family = "binomial",
# control = glmerControl(optimizer = "bobyqa"),
# nAGQ = 10)
# summary(m_null)To come back and reinterpret… don’t really know at this stage.
Test flexplot and broom.mixed usage:
# #devtools::install_github("dustinfife/flexplot")
# library(flexplot)Here it has some examples of code and output for saved logistic model fits
# # don't think flexplot will be super useful as we have so many categorical variables
# flexplot::logistic_fit
# flexplot::mixed_logistic
# flexplot::visualize(m_null)
#
# # broom.mixed is used to tidy up the stats outputs into a tibble
# broom.mixed::tidy(m_null) # summary output in tibble
# broom.mixed::glance(m_null) # model performance summaryRandom effects model
- Including individual level variables only with country:
# n_randeffect <- glmer(trans_docs ~
# gender + age + I(age^2) + life_sat + religion + social_class +
# (1|country),
# data = complete_df,
# family = "binomial",
# control = glmerControl(optimizer = "bobyqa"),
# nAGQ = 10)This suggests the data needs to be rescaled, to check which variables are the issue:
# # check for nearzero variance, if so those could be removed
# nearZeroVar(complete_df, saveMetrics = TRUE)
# # see no issues. So all variables stay.
#
# # will recode the numeric variables I selected, which is only age
# scaled_df <- complete_df |>
# mutate(across(where(is.numeric), scale))Re check the random effects model with scaled data:
# n_randeffect <- glmer(trans_docs ~
# gender + age + I(age^2) + life_sat + (1|country),
# data = scaled_df,
# family = "binomial",
# control = glmerControl(optimizer = "bobyqa"),
# nAGQ = 10)
#
#
#
# summary(n_randeffect)Can we interpret this…
Example Random effects models: m <- glmer(remission ~ IL6 + CRP + CancerStage + LengthofStay + Experience + (1 | DID), data = hdp, family = binomial, control = glmerControl(optimizer = “bobyqa”), nAGQ = 10)
Example from last year code glm_model_4 <- glmer(binary_qc19 ~ male + d11 + I(d11^2) + political_ideology + Religion_cat + sd1_7_factor + d60_ordinal + qc15_1_ordinal + prop_gndr_bin + prop_dis_wide + Unemployment + (1 | country_name), data = Data, family = binomial, control = glmerControl(optimizer = “bobyqa”, optCtrl = list(maxfun = 100000)))
Potentially useful package for visualising and interpreting linear mixed models: Flexplot -> https://github.com/dustinfife/flexplot Functions to quickly visualise LMM models and compare their performance.
broom.mixed The function broom.mixed::tidy() gives us all model parameters (random and fixed).
Useful calculations: - ICC (intra cluster correlation. How alike each of the observations within each group are) - ANOVA for model comparison: anova(null_model, lvl1_preds_model, lvl2_preds_model, rs_preds_model)